Nova Edit Installer

local outfile = "NovaEdit"
local infile = "NovaEditInstall"
local outfile = outfile or infile
--PackageStart
local files = {
    ["main.lua"] = "\
local w, h = term.getSize( )\
\
local interface = New.Interface( )\
\
local code = interface:NewChild( Resources.Programs.Code )\
code:Move( 1, 2 )\
code:Resize( w, h - 1 )\
code:UseLuaSyntax( )\
code.backgroundColour = New.Colour \"white\"\
code.lineColour = New.Colour \"white\"\
code.textColour = New.Colour \"black\"\
\
code:SetActive( false )\
\
local topBar = interface:NewChild( Resources.Programs.Tabs )\
topBar:Move( 2, 1 )\
topBar:Resize( w - 3, 1 )\
topBar.backgroundColour = New.Colour \"lightBlue\"\
topBar.tabColour = New.Colour \"cyan\"\
topBar.textColour = New.Colour \"white\"\
\
local topBarLeft, topBarRight = interface:NewChild( New.GUIButton( 1, 1, 1, 1, \"<\" ) ), interface:NewChild( New.GUIButton( w-3, 1, 1, 1, \">\" ) )\
topBarLeft.backgroundColour, topBarRight.backgroundColour = New.Colour \"blue\", New.Colour \"blue\"\
topBarLeft.textColour, topBarRight.textColour = New.Colour \"white\", New.Colour \"white\"\
topBarLeft:SetCallback( \"OnClick\", function( )\
    topBar:Scroll( -1 )\
end )\
topBarRight:SetCallback( \"OnClick\", function( )\
    topBar:Scroll( 1 )\
end )\
\
topBarClose = interface:NewChild( New.GUIButton( w, 1, 1, 1, \"x\" ) )\
topBarClose.backgroundColour = New.Colour \"red\"\
topBarClose.textColour = New.Colour \"white\"\
topBarClose:SetCallback( \"OnClick\", function( )\
    local prog = Resources.Programs.GetProgram( )\
    if prog then\
        Resources.Programs.RemoveProgram( prog.id )\
    end\
end )\
\
topBarAdd = interface:NewChild( New.GUIButton( w - 1, 1, 1, 1, \"+\" ) )\
topBarAdd.backgroundColour = New.Colour \"blue\"\
topBarAdd.textColour = New.Colour \"white\"\
topBarAdd:SetCallback( \"OnClick\", function( )\
    Resources.Window.OpenFile( interface, function( path )\
        Resources.Programs.AddProgram( path )\
    end )\
end )\
\
topBarSave = interface:NewChild( New.GUIButton( w - 2, 1, 1, 1, \"s\" ) )\
topBarSave.backgroundColour = New.Colour \"blue\"\
topBarSave.textColour = New.Colour \"white\"\
topBarSave:SetCallback( \"OnClick\", function( )\
    local prog = Resources.Programs.GetProgram( )\
    if prog then\
        Resources.Programs.SelectProgram( prog.id )\
        local h = rootfs.open( prog.path, \"w\" )\
        if h then\
            h.write( prog.content )\
            h.close( )\
        end\
    end\
end )\
\
interface:Run( function( ) return true end )",
    run = " \
local path = \"NovaEdit\"\
local args = { ... }\
\
local f, err = loadfile( \"Nova/.launcher/Utils.lua\" )\
if not f then\
    error( err, 0 )\
end\
setfenv( f, getfenv( ) )\
local utils = f( fs )\
assert( utils.isValidPath( path ), \"Incorrect package\" )\
\
local config = utils.loadConfig( path..\"/main.conf\" )\
local classpath = tostring( config.classpath or \"class\" )\
local respath = tostring( config.resources or \"res\" )\
\
assert( fs.isDir( path..\"/\"..classpath ), \"Incorrect package: Class folder not found.\" )\
assert( fs.exists( path..\"/\"..classpath..\"/FilesystemRedirect.class\" ), \"Incorrect package: FilesystemRedirect class not found.\" )\
\
local New, Class, classes = utils.loadClasses( path..\"/class.lua\", path..\"/\"..classpath )\
local env, filesystem = utils.formatEnvironment( path, classes, Class )\
\
if fs.isDir( path..\"/\"..respath ) then\
    utils.loadResources( path..\"/\"..respath, env )\
end\
\
local needUpdating = fs.list( path..\"/uclass\" )\
for k, v in pairs( needUpdating ) do\
    classes[v] = Class.Load( v, path..\"/\"..classpath, env )\
end\
\
utils.run( path, env, config, filesystem, args )",
    res =   {
        ["Programs.lua"] = "\
local active = 0\
local programs = { }\
local programsF = { }\
local current = 0\
local id = 1\
Code = New.GUICode( 1, 1, 1, 1 )\
Tabs = New.GUITabs( 1, 1, 1, 1, programsF )\
\
AddProgram = function( path )\
    local name = fs.getName( path )\
    local content = \"\"\
    local h = rootfs.open( path, \"r\" )\
    if h then\
        content = h.readAll( )\
        h.close( )\
    end\
    programs[id] = { id = id, name = name, content = content, path = path }\
    table.insert( programsF, id )\
    active = active + 1\
    SelectProgram( id )\
    id = id + 1\
    return id - 1\
end\
\
SelectProgram = function( id )\
    if programs[current] then\
        programs[current].content = Code:GetText( )\
    end\
    if programs[id] and id ~= current then\
        Code:SetText( programs[id].content )\
        Code:SetActive( true )\
    elseif not programs[id] then\
        Code:SetLines( { \"\" } )\
        Code:SetActive( false )\
    end\
    current = id\
end\
\
RemoveProgram = function( id )\
    active = active - 1\
    if active <= 0 then\
        Code:SetActive( false )\
        active = 0\
    end\
    for i = #programsF, 1, -1 do\
        if programsF[i] == id then\
            table.remove( programsF, i )\
        end\
    end\
    programs[id] = nil\
    SelectProgram( next( programs ) )\
end\
\
GetProgram = function( id )\
    return programs[id or current]\
end\
\
Tabs:SetCallback( \"FormatOption\", function( self, tab, n )\
    local prog = programs[tab]\
    if prog then\
        return prog.name\
    else\
        return \"IDK\"\
    end\
end )\
Tabs:SetCallback( \"OnSelect\", function( self, tab, button, n )\
    SelectProgram( tab )\
end )",
        ["Window.lua"] = "\
local w, h = term.getSize( )\
\
OpenFile = function( frame, onConfirm, needsToExist )\
    local backField = frame:NewChild( New.GUIField( 1, 1, frame.width, frame.height ) )\
    backField:SetVisible( false )\
    local x, y = math.floor( w / 2 - 11 ), math.floor( h / 2 - 3.5 )\
    local popup = frame:NewChild( New.GUIFrame( x, y, 24, 7 ) )\
    local field = popup:NewChild( New.GUIField( 1, 1, 24, 7, New.Colour \"lightBlue\" ) )\
    local title = popup:NewChild( New.GUIText( 2, 2, 22, 1, \"Open file:\" ) )\
    title.backgroundColour = New.Colour \"cyan\"\
    local path = popup:NewChild( New.GUIInput( 2, 4, 22, 1 ) )\
    path.backgroundColour = New.Colour \"lightGrey\"\
    path.focussedBackgroundColour = New.Colour \"white\"\
    path.emptyText = \"Path to file\"\
    local yes, no = popup:NewChild( New.GUIButton( 2, 6, 11, 1, \"Confirm\" ) ), popup:NewChild( New.GUIButton( 14, 6, 10, 1, \"Cancel\" ) )\
    yes.backgroundColour, no.backgroundColour = New.Colour \"blue\", New.Colour \"blue\"\
    yes.textColour, no.textColour = New.Colour \"white\", New.Colour \"white\"\
    yes:SetCallback( \"OnClick\", function( )\
        local p = path.text\
        if not rootfs.isDir( p ) and ( not needsToExist or rootfs.exists( p ) ) then\
            popup:Remove( )\
            backField:Remove( )\
            onConfirm( p )\
        end\
    end )\
    no:SetCallback( \"OnClick\", function( )\
        popup:Remove( )\
        backField:Remove( )\
    end )\
end",
    },
    class =     {
        ["GUIText.class"] = "\
local function linewrap( str, w, mode )\
    for i = 1,w + 1 do\
        if str:sub( i, i ) == \"\\n\" then\
            return str:sub( 1, i-1 ), str:sub( i + 1 )\
        end\
    end\
    if #str <= w then return str end\
    if mode == \"none\" then\
        for i = 1,#str do\
            if str:sub( i, i ) == \"\\n\" then\
                return str:sub( 1, i - 1 ), str:sub( i + 1 )\
            end\
        end\
        return str\
    end\
    local mode = mode or \"hard\"\
    local function isSpacer( char ) return char == \" \" or char == \"\\n\" end\
    local s = isSpacer( str:sub( w + 1, w + 1 ) )\
    if not s then\
        for i = w, 1, -1 do\
            if str:sub( i, i ) == \"\\n\" then\
                return str:sub( 1, i - 1 ), str:sub( i + 1 )\
            elseif isSpacer( str:sub( i, i ) ) then\
                return str:sub( 1, i ), str:sub( i + 1 )\
            end\
        end\
    end\
    if mode == \"soft\" then\
        local line, str = str:sub( 1, w ), str:sub( w + 1 )\
        while isSpacer( str:sub( 1, 1 ) ) do\
            if str:sub( 1, 1 ) == \"\\n\" then\
                return line, str:sub( 2 )\
            end\
            line = line..str:sub( 1, 1 )\
            str = str:sub( 2 )\
        end\
        return line, str\
    end\
    return str:sub( 1, w ), str:sub( w + 1 )\
end\
\
local function wordwrap( str, w, h, mode )\
    local lines = { }\
    while str do\
        lines[#lines+1], str = linewrap( str, w, mode )\
    end\
    if h then while #lines > h do table.remove( lines, #lines ) end end\
    return lines\
end\
\
GUIText:Extends( \"GUIBase\" )\
\
GUIText:AddPrivateVariable( \"lines\", { }, \"table\" )\
\
GUIText:AddVariable( \"backgroundColour\", New.Colour( \"white\" ), \"Colour\" )\
GUIText:AddVariable( \"textColour\", New.Colour( \"black\" ), \"Colour\" )\
GUIText:AddVariable( \"text\", \"\", \"string\", \"function\", \"number\", \"boolean\", \"String\" )\
GUIText:AddVariable( \"alignment\", \"left\", \"string\", \"String\" )\
GUIText:AddVariable( \"wrapmode\", \"soft\", \"string\", \"String\" )\
\
GUIText:AddMethod( \"GetText\", function( self, var )\
    local text = var( \"get\", \"public\", \"text\" )\
    if type( text ) == \"function\" then\
        return tostring( text( ) )\
    end\
    return tostring( text )\
end )\
GUIText:AddMethod( \"GetLines\", function( self, var )\
    return var( \"get\", \"private\", \"lines\" )\
end )\
GUIText:AddMethod( \"UpdateLines\", function( self, var )\
    return var( \"set\", \"private\", \"lines\", wordwrap( self:GetText( ), self.width, self.height, tostring( self.wrapmode ) ) )\
end )\
\
GUIText:AddMethod( \"GetLineOffset\", function( self, var, line )\
    if tostring( self.alignment ) == \"centre\" or tostring( self.alignment ) == \"vcentre\" then\
        return math.floor( self.width / 2 - #line / 2 )\
    elseif tostring( self.alignment ) == \"right\" then\
        return self.width - #line\
    end\
    return 0\
end )\
GUIText:AddMethod( \"GetYOffset\", function( self, var )\
    if tostring( self.alignment ) == \"vcentre\" then\
        return math.floor( self.height / 2 - #var( \"get\", \"private\", \"lines\" ) / 2 )\
    end\
    return 0\
end )\
\
GUIText:AddPrivateMethod( \"GetClickPosition\", function( self, var, x, y )\
    local yoffset = self:GetYOffset( )\
    local y = y - yoffset\
    local lines = var( \"get\", \"private\", \"lines\" )\
    local width = self.width\
    local char = 0\
    for i = 1,y-1 do\
        if lines[i] then\
            char = char + #lines[i]\
        end\
    end\
    if lines[y] then\
        local xoffset = self:GetLineOffset( lines[y] )\
        local x = x - xoffset\
        local n, after = \"\", false\
        if x > #lines[y] then\
            after = true\
            n = char + #lines[y] + 1\
        else\
            n = char + x\
        end\
        return n, after\
    else\
        return char + 1\
    end\
end )\
GUIText:AddPrivateMethod( \"GetCursorPosition\", function( self, var, char )\
    local lines = var( \"get\", \"private\", \"lines\" )\
    local y = 0\
    local csf = 0\
    for i = 1,#lines do\
        y = y + 1\
        if csf + #lines[y] >= char then\
            local spacing = self:GetLineOffset( y )\
            return char - csf + spacing, y + self:GetYOffset( )\
        end\
        csf = csf + #lines[i]\
    end\
    return #lines[y] + 1, y + self:GetYOffset( )\
end )\
\
GUIText:AddStaticVariable( \"Render\", function( self, x, y )\
    local width = self.width\
    local height = self.height\
    local lines = self:GetLines( )\
    term.setBackgroundColour( self.backgroundColour:Get( ) )\
    term.setTextColour( self.textColour:Get( ) )\
    local yoffset = self:GetYOffset( )\
    for i = 1,height do\
        local line = string.rep( \" \", self:GetLineOffset( lines[i-yoffset] or \"\" ) )..( lines[i-yoffset] or \"\" )\
        term.setCursorPos( x, y + i - 1 )\
        term.write( line:sub( 1, width ) )\
        if #line < width then\
            term.write( string.rep( \" \", width - #line ) )\
        end\
    end\
end )\
\
GUIText:AddStaticVariable( \"Update\", function( self )\
    self:UpdateLines( )\
end )\
\
function GUIText:Describe( )\
    return \"GUI Text object\"\
end\
\
function GUIText:Init( var, args )\
    if Class.CheckTypeOf( args[5], \"string\", \"String\" ) then\
        self.text = args[5]\
    end\
    var( \"set\", \"public\", \"backgroundColour\", New.Colour( \"white\" ) )\
    var( \"set\", \"public\", \"textColour\", New.Colour( \"black\" ) )\
end",
        ["GUIFrame.class"] = "\
GUIFrame:Extends( \"GUIBase\" )\
\
GUIFrame:AddPrivateVariable( \"children\", { }, \"table\" )\
\
GUIFrame:AddMethod( \"GetChildren\", function( self, var )\
    local t = { }\
    local children = var( \"get\", \"private\", \"children\" )\
    for i = 1,#children do\
        t[i] = children[i]\
    end\
    return t\
end )\
GUIFrame:AddMethod( \"NewChild\", function( self, var, child )\
    if Class.CheckTypeOf( child, \"GUIBase\" ) then\
        child.parent = self\
        local children = var( \"get\", \"private\", \"children\" )\
        table.insert( children, child )\
        return child\
    end\
    return false\
end )\
GUIFrame:AddMethod( \"RemoveChild\", function( self, var, child )\
    if Class.CheckTypeOf( child, \"GUIBase\" ) then\
        local children = var( \"get\", \"private\", \"children\" )\
        for i = #children, 1, -1 do\
            if children[i] == child then\
                table.remove( children, i )\
            end\
        end\
        child.parent = nil\
        return child\
    end\
    return false\
end )\
GUIFrame:AddMethod( \"Focus\", function( self, var, child )\
    local children = self:GetChildren( )\
    for i = 1,#children do\
        if children[i] == child then\
            table.remove( children, i )\
            table.insert( children, child )\
            break\
        end\
    end\
    var( \"set\", \"private\", \"children\", children )\
end )\
\
GUIFrame:AddStaticVariable( \"Update\", function( self, ... )\
    if not self.active then return end\
    local data = { ... }\
    local children = self:GetChildren( )\
    for i = 1,#children do\
        if children[i].active then\
            children[i]:Update( unpack( data ) )\
        end\
    end\
end, \"function\" )\
GUIFrame:AddStaticVariable( \"Render\", function( self, x, y, ... )\
    if not self.visible then return end\
    local data = { ... }\
    local children = self:GetChildren( )\
    for i = 1,#children do\
        if children[i].visible then\
            local xx, yy = x + children[i].x - 1, y + children[i].y - 1\
            children[i]:Render( xx, yy, unpack( data ) )\
        end\
    end\
end, \"function\" )\
GUIFrame:AddStaticVariable( \"MouseEvent\", function( self, x, y, ... )\
    if not self.active then return end\
    local ev = { ... }\
    local children = self:GetChildren( )\
    for i = 1,#children do\
        if children[i].active then\
            xx = x - children[i].x + 1\
            yy = y - children[i].y + 1\
            children[i]:MouseEvent( xx, yy, unpack( ev ) )\
        end\
    end\
end, \"function\" )\
GUIFrame:AddStaticVariable( \"Event\", function( self, ... )\
    if not self.active then return end\
    local ev = { ... }\
    local children = self:GetChildren( )\
    for i = 1,#children do\
        if children[i].active then\
            children[i]:Event( unpack( ev ) )\
        end\
    end\
end, \"function\" )\
\
GUIFrame:AddMethod( \"FindMouseTarget\", function( self, var, x, y )\
    if type( x ) == \"number\" and type( y ) == \"number\" then\
        local callback\
        callback = function( parent, x, y )\
            local children = parent:GetChildren( )\
            for i = #children, 1, -1 do\
                local child = children[i]\
                if child.active and x >= child.x and x < child.x + child.width and y >= child.y and y < child.y + child.height then\
                    if child:TypeOf( \"GUIFrame\" ) then\
                        local result = callback( child, x - child.x + 1, y - child.y + 1 )\
                        if result then\
                            return result\
                        end\
                    else\
                        return child\
                    end\
                end\
            end\
        end\
        return callback( self, x, y )\
    else\
        error( \"Expected number, number, got \"..type( x )..\", \"..type( y ), 2 )\
    end\
end )\
GUIFrame:AddMethod( \"FindKeyboardTarget\", function( self, var )\
    local callback\
    callback = function( parent )\
        local children = parent:GetChildren( )\
        for i = #children, 1, -1 do\
            if children[i].active and children[i].handlesKeyboard == true or ( type( children[i].handlesKeyboard ) == \"function\" and children[i]:handlesKeyboard( ) ) then\
                return children[i]\
            end\
            if children[i].active and children[i]:TypeOf( \"GUIFrame\" ) then\
                local result = callback( children[i] )\
                if result then\
                    return result\
                end\
            end\
        end\
        return false\
    end\
    return callback( self )\
end )\
\
function GUIFrame:Describe( )\
    return \"GUI Frame object\"\
end\
\
function GUIFrame:Init( var, args )\
    var( \"set\", \"private\", \"children\", { } )\
    if type( args[5] ) == \"table\" then\
        for i = 1,#args[5] do\
            local child = args[5][i]\
            if Class.CheckTypeOf( child, \"GUIBase\" ) then\
                self:NewChild( child )\
            end\
        end\
    end\
end",
        ["Interface.class"] = "\
Interface:AddVariable( \"frame\", New.GUIFrame( 1, 1, term.getSize( ) ), \"GUIBase.GUIFrame\" )\
Interface:AddVariable( \"backgroundColour\", New.Colour \"black\", \"Colour\" )\
Interface:AddPrivateVariable( \"lastMouse\", false, \"table\" )\
\
Interface:AddMethod( \"Update\", function( self, var )\
    self.frame:Update( )\
end )\
Interface:AddMethod( \"Render\", function( self, var )\
    self.frame:Render( 1, 1 )\
    local x, y, c = self.frame:GetCursorData( )\
    self.frame:ResetCursorData( )\
    if x then\
        term.setTextColour( c )\
        term.setCursorPos( x, y )\
        term.setCursorBlink( true )\
    else\
        term.setCursorBlink( false )\
    end\
end )\
Interface:AddMethod( \"Event\", function( self, var, ... )\
    local ev = { ... }\
    if #ev == 1 and type( ev[1] ) == \"table\" then\
        ev = ev[1]\
    end\
\
    if ev[1]:sub( 1, 6 ) == \"mouse_\" then\
        local mev = { }\
        mev.type = ev[1] == \"mouse_click\" and \"Click\" or ev[1] == \"mouse_drag\" and \"Drag\" or ev[1] == \"mouse_scroll\" and \"Scroll\" or ev[1]\
        mev.button = ev[2]\
        mev.x = ev[3]\
        mev.y = ev[4]\
        local data = var( \"get\", \"private\", \"lastMouse\" )\
        if mev.type == \"Drag\" and data then\
            mev.target = data.target\
            mev.xchange = ev[3] - data.x\
            mev.ychange = ev[4] - data.y\
        else\
            mev.target = self.frame:FindMouseTarget( ev[3], ev[4] )\
        end\
        self.frame:MouseEvent( ev[3], ev[4], mev )\
        if mev.type == \"Drag\" or mev.type == \"Click\" then\
            var( \"set\", \"private\", \"lastMouse\", mev )\
        end\
        return\
    end\
    local mev = { }\
    for k, v in pairs( ev ) do\
        mev[k] = v\
    end\
    if ev[1] == \"key\" or ev[1] == \"char\" then\
        mev = { }\
        mev[1] = \"Keyboard\"\
        mev[2] = ev[1] == \"char\"\
        if ev[1] == \"key\" then\
            mev[3] = keys.getName( ev[2] )\
            mev[4] = ev[2]\
        else\
            mev[3] = ev[2]\
            mev[4] = keys[ev[2]]\
        end\
        mev[5] = self.frame:FindKeyboardTarget( )\
    end\
    self.frame:Event( mev )\
end )\
Interface:AddMethod( \"NewChild\", function( self, var, child )\
    return self.frame:NewChild( child )\
end )\
Interface:AddMethod( \"GetChildren\", function( self, var )\
    return self.frame:GetChildren( )\
end )\
Interface:AddMethod( \"Run\", function( self, var, onTerminate, running, noClear )\
    term.setBackgroundColour( 32768 )\
    term.clear( )\
    local timer, time = os.startTimer( 0 ), os.clock( )\
    while type( running ) ~= \"function\" or running( ) do\
        local ev = { coroutine.yield( ) }\
        if ev[1] == \"terminate\" and type( onTerminate ) == \"function\" then\
            if onTerminate( ) then\
                break\
            end\
        end\
        if ev[1] ~= \"timer\" or ev[2] ~= timer and ev[1] ~= \"terminate\" then\
            self:Event( unpack( ev ) )\
        end\
        if ( ev[1] == \"timer\" and ev[2] == timer ) or time + 0.1 < os.clock( ) then\
            if not noClear then\
                term.setBackgroundColour( self.backgroundColour:Get( ) )\
                term.clear( )\
            end\
            self:Update( )\
            self:Render( )\
\
            timer = os.startTimer( 0.05 )\
            time = os.clock( )\
        end\
    end\
end )\
\
function Interface:Init( var, args )\
    if type( args[1] ) == \"table\" and args[1].typeOf and args[1]:typeOf( \"GUIFrame\" ) then\
        self.frame = args[1]\
    end\
    var( \"set\", \"private\", \"lastMouse\", { } )\
    var( \"set\", \"public\", \"backgroundColour\", New.Colour \"black\" )\
end",
        ["GUIBase.class"] = "\
GUIBase:AddStaticVariable( \"x\", 0, \"number\" )\
GUIBase:AddStaticVariable( \"y\", 0, \"number\" )\
GUIBase:AddStaticVariable( \"width\", 0, \"number\" )\
GUIBase:AddStaticVariable( \"height\", 0, \"number\" )\
\
GUIBase:AddStaticVariable( \"visible\", true, \"boolean\" )\
GUIBase:AddStaticVariable( \"active\", true, \"boolean\" )\
GUIBase:AddStaticVariable( \"handlesKeyboard\", false, \"boolean\" )\
\
GUIBase:AddStaticVariable( \"Update\", function( ) end, \"function\" )\
GUIBase:AddStaticVariable( \"Render\", function( ) end, \"function\" )\
GUIBase:AddStaticVariable( \"MouseEvent\", function( ) end, \"function\" )\
GUIBase:AddStaticVariable( \"Event\", function( ) end, \"function\" )\
\
GUIBase:AddPrivateVariable( \"callbacks\", { }, \"table\" )\
GUIBase:AddPrivateVariable( \"cursor\", { }, \"table\" )\
GUIBase:AddVariable( \"parent\", false, \"GUIBase.GUIFrame\", \"nil\" )\
\
GUIBase:AddMethod( \"SetX\", function( self, var, x )\
    if type( x ) == \"number\" then\
        var( \"set\", \"static\", \"x\", math.floor( x ) )\
    else\
        error( \"Expected number, got \"..type( x ), 2 )\
    end\
end )\
GUIBase:AddMethod( \"SetY\", function( self, var, y )\
    if type( y ) == \"number\" then\
        var( \"set\", \"static\", \"y\", math.floor( y ) )\
    else\
        error( \"Expected number, got \"..type( y ), 2 )\
    end\
end )\
GUIBase:AddMethod( \"Move\", function( self, var, x, y, mode )\
    if ( type( x ) == \"number\" and type( y ) == \"number\" ) or mode == \"add\" then\
        if mode == \"add\" then\
            x = ( x or 0 ) + self.x\
            y = ( y or 0 ) + self.y\
        end\
        var( \"set\", \"static\", \"x\", math.floor( x ) )\
        var( \"set\", \"static\", \"y\", math.floor( y ) )\
    elseif type( x ) == \"table\" and x.x and x.y then\
        local mode = y\
        x, y = x.x, x.y\
        if mode == \"add\" then\
            x = x + self.x\
            y = y + self.y\
        end\
        var( \"set\", \"static\", \"x\", math.floor( x ) )\
        var( \"set\", \"static\", \"y\", math.floor( y ) )\
    else\
        error( \"Expected number, number, got \"..type( x )..\", \"..type( y ), 2 )\
    end\
end )\
\
GUIBase:AddMethod( \"SetWidth\", function( self, var, w )\
    if type( w ) == \"number\" then\
        var( \"set\", \"static\", \"width\", math.floor( w ) )\
    else\
        error( \"Expected number, got \"..type( w ), 2 )\
    end\
end )\
GUIBase:AddMethod( \"SetHeight\", function( self, var, h )\
    if type( h ) == \"number\" then\
        var( \"set\", \"static\", \"height\", math.floor( h ) )\
    else\
        error( \"Expected number, got \"..type( h ), 2 )\
    end\
end )\
GUIBase:AddMethod( \"Resize\", function( self, var, w, h, mode )\
    if ( type( w ) == \"number\" and type( h ) == \"number\" ) or mode == \"add\" then\
        if mode == \"add\" then\
            w = ( w or 0 ) + self.width\
            h = ( h or 0 ) + self.height\
        end\
        var( \"set\", \"static\", \"width\", math.floor( w ) )\
        var( \"set\", \"static\", \"height\", math.floor( h ) )\
    elseif type( w ) == \"table\" and w.x and w.y then\
        local mode = h\
        w, h = w.x, w.y\
        if mode == \"add\" then\
            w = w + self.w\
            h = h + self.h\
        end\
        var( \"set\", \"static\", \"w\", math.floor( w ) )\
        var( \"set\", \"static\", \"h\", math.floor( h ) )\
    else\
        error( \"Expected number, number, got \"..type( w )..\", \"..type( h ), 2 )\
    end\
end )\
\
GUIBase:AddMethod( \"SetVisible\", function( self, var, bool )\
    var( \"set\", \"static\", \"visible\", not not bool )\
end )\
GUIBase:AddMethod( \"ToggleVisible\", function( self, var )\
    var( \"set\", \"static\", \"visible\", not var( \"get\", \"private\", \"visible\" ) )\
end )\
\
GUIBase:AddMethod( \"SetActive\", function( self, var, bool )\
    var( \"set\", \"static\", \"active\", not not bool )\
end )\
GUIBase:AddMethod( \"ToggleActive\", function( self, var )\
    var( \"set\", \"static\", \"active\", not var( \"get\", \"private\", \"active\" ) )\
end )\
\
GUIBase:AddMethod( \"SetCallback\", function( self, var, name, func )\
    if Class.CheckTypeOf( name, \"string\", \"String\" ) and type( func ) == \"function\" then\
        local callbacks = var( \"get\", \"private\", \"callbacks\" )\
        callbacks[tostring( name )] = func\
        return true\
    end\
    return false\
end )\
GUIBase:AddMethod( \"GetCallback\", function( self, var, name )\
    if Class.CheckTypeOf( name, \"string\", \"String\" ) then\
        local callbacks = var( \"get\", \"private\", \"callbacks\" )\
        return callbacks[tostring( name )]\
    end\
    return false\
end )\
\
GUIBase:AddMethod( \"Remove\", function( self, var )\
    local parent = var( \"get\", \"public\", \"parent\" )\
    if parent then\
        parent:RemoveChild( self )\
    end\
end )\
GUIBase:AddMethod( \"FocusOn\", function( self, var )\
    local parent = var( \"get\", \"public\", \"parent\" )\
    if parent then\
        parent:Focus( self )\
    end\
end )\
\
GUIBase:AddMethod( \"RequestCursorBlink\", function( self, var, x, y, colour )\
    var( \"set\", \"private\", \"cursor\", { x = x, y = y, colour = colour } )\
    local parent = var( \"get\", \"public\", \"parent\" )\
    if parent then\
        parent:RequestCursorBlink( x, y, colour )\
    end\
end )\
GUIBase:AddMethod( \"GetCursorData\", function( self, var )\
    local t = var( \"get\", \"private\", \"cursor\" )\
    return t.x, t.y, t.colour\
end )\
GUIBase:AddMethod( \"ResetCursorData\", function( self, var, x, y, colour )\
    var( \"set\", \"private\", \"cursor\", { { } } )\
    local parent = var( \"get\", \"public\", \"parent\" )\
    if parent then\
        parent:ResetCursorData( x, y, colour )\
    end\
end )\
\
function GUIBase:Describe( )\
    return \"GUI Base object\"\
end\
\
function GUIBase:Init( var, args )\
    var( \"set\", \"private\", \"callbacks\", { } )\
    var( \"set\", \"private\", \"cursor\", { } )\
    if type( args[1] ) == \"number\" and type( args[2] ) == \"number\" then\
        self:Move( args[1], args[2] )\
    end\
    if type( args[3] ) == \"number\" and type( args[4] ) == \"number\" then\
        self:Resize( args[3], args[4] )\
    end\
end",
        ["GUIInput.class"] = "\
GUIInput:Extends( \"GUIBase\" )\
\
GUIInput:AddVariable( \"mask\", false, \"string\", \"String\", \"boolean\" )\
GUIInput:AddVariable( \"text\", \"\", \"string\", \"String\" )\
GUIInput:AddVariable( \"emptyText\", \"\", \"string\", \"String\" )\
GUIInput:AddVariable( \"canScroll\", false, \"boolean\" )\
\
GUIInput:AddVariable( \"backgroundColour\", New.Colour( \"white\" ), \"Colour\" )\
GUIInput:AddVariable( \"textColour\", New.Colour( \"black\" ), \"Colour\" )\
GUIInput:AddVariable( \"focussedBackgroundColour\", New.Colour( \"white\" ), \"Colour\" )\
GUIInput:AddVariable( \"focussedTextColour\", New.Colour( \"black\" ), \"Colour\" )\
\
GUIInput:AddPrivateVariable( \"scroll\", 0, \"number\" )\
GUIInput:AddPrivateVariable( \"cursor\", 1, \"number\" )\
GUIInput:AddPrivateVariable( \"focussed\", false, \"boolean\" )\
\
GUIInput:AddMethod( \"SetHeight\", function( self, var, h )\
    if type( h ) == \"number\" then\
        var( \"set\", \"static\", \"height\", 1 )\
    else\
        error( \"Expected number, got \"..type( h ), 2 )\
    end\
end )\
GUIInput:AddMethod( \"Resize\", function( self, var, w, h, mode )\
    if ( type( w ) == \"number\" and type( h ) == \"number\" ) or mode == \"add\" then\
        if mode == \"add\" then\
            w = ( w or 0 ) + self.width\
        end\
        var( \"set\", \"static\", \"width\", math.floor( w ) )\
        var( \"set\", \"static\", \"height\", 1 )\
    elseif type( w ) == \"table\" and w.x and w.y then\
        local mode = h\
        w, h = w.x, w.y\
        if mode == \"add\" then\
            w = w + self.w\
        end\
        var( \"set\", \"static\", \"w\", math.floor( w ) )\
        var( \"set\", \"static\", \"h\", 1 )\
    else\
        error( \"Expected number, number, got \"..type( w )..\", \"..type( h ), 2 )\
    end\
end )\
\
GUIInput:AddMethod( \"handlesKeyboard\", function( self, var )\
    return var( \"get\", \"private\", \"focussed\" )\
end )\
\
GUIInput:AddMethod( \"SetCursorPos\", function( self, var, x )\
    local c, s = var( \"get\", \"private\", \"cursor\" ), var( \"get\", \"private\", \"scroll\" )\
    var( \"set\", \"private\", \"cursor\", math.max( math.min( x, #tostring( self.text ) + 1 ), 1 ) )\
    local x = var( \"get\", \"private\", \"cursor\" )\
    local p = var( \"get\", \"private\", \"scroll\" )\
    if x - p <= 1 then\
        var( \"set\", \"private\", \"scroll\", math.max( x - 2, 0 ) )\
    elseif x - p > self.width then\
        var( \"set\", \"private\", \"scroll\", math.max( x - self.width, 0 ) )\
    end\
end )\
\
GUIInput:AddMethod( \"MouseEvent\", function( self, var, x, y, ev )\
    if ev.target == self then\
        var( \"set\", \"private\", \"focussed\", true )\
        var( \"set\", \"private\", \"cursor\", math.min( var( \"get\", \"private\", \"scroll\" ) + x, #tostring( self.text ) + 1 ) )\
    else\
        var( \"set\", \"private\", \"focussed\", false )\
    end\
end )\
\
GUIInput:AddMethod( \"Event\", function( self, var, ev )\
    if ev[1] == \"Keyboard\" and ev[5] == self and var( \"get\", \"private\", \"focussed\" ) then\
        local text = tostring( self.text )\
        local len = #text\
        local pos = var( \"get\", \"private\", \"cursor\" )\
        if ev[3] == \"enter\" then\
            local callback = self:GetCallback( \"KeyPressEnter\" )\
            if callback then\
                callback( self )\
            else\
                var( \"set\", \"private\", \"focussed\", false )\
            end\
        elseif ev[3] == \"tab\" then\
            local callback = self:GetCallback( \"KeyPressTab\" )\
            if callback then\
                callback( self )\
            else\
                var( \"set\", \"private\", \"focussed\", false )\
            end\
        elseif ev[3] == \"backspace\" and pos > 1 then\
            self.text = text:sub( 1, pos - 2 )..text:sub( pos )\
            self:SetCursorPos( pos - 1 )\
        elseif ev[3] == \"delete\" then\
            self.text = text:sub( 1, pos - 1 )..text:sub( pos + 1 )\
        elseif ev[2] and len < self.width or self.canScroll then\
            self.text = text:sub( 1, pos - 1 )..ev[3]..text:sub( pos )\
            self:SetCursorPos( pos + 1 )\
        elseif ev[3] == \"left\" then\
            self:SetCursorPos( pos - 1 )\
        elseif ev[3] == \"right\" then\
            self:SetCursorPos( pos + 1 )\
        end\
    end\
end )\
\
GUIInput:AddMethod( \"Render\", function( self, var, x, y )\
    local text = self.text\
    if self.mask then\
        if self.mask == true then\
            text = string.rep( \"*\", #tostring( self.text ) )\
        else\
            text = string.rep( tostring( self.mask ):sub( 1, 1 ), #tostring( self.text ) )\
        end\
    end\
    if #text == 0 then\
        text = tostring( self.emptyText )\
    end\
    term.setCursorPos( x, y )\
    if var( \"get\", \"private\", \"focussed\" ) then\
        term.setBackgroundColour( self.focussedBackgroundColour:Get( ) )\
        term.setTextColour( self.focussedTextColour:Get( ) )\
    else\
        term.setBackgroundColour( self.backgroundColour:Get( ) )\
        term.setTextColour( self.textColour:Get( ) )\
    end\
    local s = var( \"get\", \"private\", \"scroll\" )\
    local str = text:sub( s + 1, s + self.width )\
    term.write( str..string.rep( \" \", self.width - #str ) )\
    if self.active and var( \"get\", \"private\", \"focussed\" ) then\
        self:RequestCursorBlink( x + ( var( \"get\", \"private\", \"cursor\" ) - s ) - 1, y, self.textColour:Get( ) )\
    end\
end )\
\
function GUIInput:Init( var, args )\
    if Class.CheckTypeOf( args[5], \"string\", \"String\" ) then\
        self.text = args[5]\
    end\
    var( \"set\", \"public\", \"backgroundColour\", New.Colour( \"white\" ) )\
    var( \"set\", \"public\", \"textColour\", New.Colour( \"black\" ) )\
end",
        ["Colour.class"] = "\
local findColour = function( t, n )\
    for k, v in pairs( t ) do\
        if v == n then\
            return k\
        end\
    end\
    return \"white\"\
end\
\
Colour:AddVariable( \"colour\", 1, \"string\", \"number\", \"Colour\", \"String\" )\
Colour:AddMethod( \"Get\", function( self, var )\
    if Class.CheckTypeOf( self.colour, \"string\", \"String\" ) then\
        return colours[tostring( self.colour )]\
    elseif type( self.colour ) == \"number\" then\
        return self.colour\
    else\
        return self.colour:Get( )\
    end\
end )\
Colour:AddMethod( \"GetName\", function( self, var )\
    if Class.CheckTypeOf( self.colour, \"string\", \"String\" ) then\
        return tostring( self.colour )\
    elseif type( self.colour ) == \"number\" then\
        return findColour( colours, self.colour )\
    else\
        return self.colour:GetName( )\
    end\
end )\
Colour:AddMethod( \"Set\", function( self, var, col )\
    if type( col ) == \"number\" then\
        col = findColour( colours, col )\
    elseif Class.CheckType( col, \"Colour\" ) then\
        col = col:GetName( )\
    end\
    if Class.CheckTypeOf( col, \"string\", \"String\" ) then\
        self.colour = colours[tostring( col )] or self.colour\
    end\
end )\
\
function Colour:Describe( )\
    return self:GetName( )\
end\
\
function Colour:Init( var, args )\
    if type( args[1] ) ~= \"nil\" then\
        self:Set( args[1] )\
    end\
end",
        ["GUITabs.class"] = "\
GUITabs:Extends( \"GUIBase\" )\
\
GUITabs:AddVariable( \"tabs\", { }, \"table\" )\
GUITabs:AddVariable( \"backgroundColour\", \"\", \"Colour\" )\
GUITabs:AddVariable( \"tabColour\", \"\", \"Colour\" )\
GUITabs:AddVariable( \"textColour\", \"\", \"Colour\" )\
\
GUITabs:AddPrivateVariable( \"tabOffset\", 0, \"number\" )\
\
GUITabs:AddMethod( \"Scroll\", function( self, var, n )\
    local p = math.floor( var( \"get\", \"private\", \"tabOffset\" ) + n )\
    local m = 0\
    for i = 1,#self.tabs do\
        m = m + #tostring( self.tabs[i] ) + 1\
    end\
    if p > m - self.width - 1 then p = m - self.width - 1 end\
    if p < 0 then p = 0 end\
    var( \"set\", \"private\", \"tabOffset\", p )\
end )\
\
GUITabs:AddMethod( \"SetHeight\", function( self, var, h )\
    if type( h ) == \"number\" then\
        var( \"set\", \"static\", \"height\", 1 )\
    else\
        error( \"Expected number, got \"..type( h ), 2 )\
    end\
end )\
GUITabs:AddMethod( \"Resize\", function( self, var, w, h, mode )\
    if ( type( w ) == \"number\" and type( h ) == \"number\" ) or mode == \"add\" then\
        if mode == \"add\" then\
            w = ( w or 0 ) + self.width\
        end\
        var( \"set\", \"static\", \"width\", math.floor( w ) )\
        var( \"set\", \"static\", \"height\", 1 )\
    elseif type( w ) == \"table\" and w.x and w.y then\
        local mode = h\
        w, h = w.x, w.y\
        if mode == \"add\" then\
            w = w + self.w\
        end\
        var( \"set\", \"static\", \"w\", math.floor( w ) )\
        var( \"set\", \"static\", \"h\", 1 )\
    else\
        error( \"Expected number, number, got \"..type( w )..\", \"..type( h ), 2 )\
    end\
end )\
\
GUITabs:AddMethod( \"Render\", function( self, var, x, y )\
    term.setBackgroundColour( self.backgroundColour:Get( ) )\
    term.setCursorPos( x, y )\
    term.write( string.rep( \" \", self.width ) )\
    local tabs = { }\
    local pos = -var( \"get\", \"private\", \"tabOffset\" ) + 1\
    for i = 1,#self.tabs do\
        local str\
        local callback = self:GetCallback( \"FormatOption\" )\
        if callback then\
            str = tostring( callback( self, self.tabs[i], i ) )\
        else\
            str = tostring( self.tabs[i] )\
        end\
        local t = { pos = pos, str = str, len = #str }\
        tabs[i] = t\
        pos = pos + tabs[i].len + 1\
    end\
    term.setBackgroundColour( self.tabColour:Get( ) )\
    term.setTextColour( self.textColour:Get( ) )\
    for i = 1,#tabs do\
        term.setCursorPos( x + tabs[i].pos - 1, y )\
        local str = tabs[i].str\
        if tabs[i].pos < 1 then\
            str = str:sub( math.abs( tabs[i].pos ) + 2 )\
            term.setCursorPos( x, y )\
        end\
        if tabs[i].pos + tabs[i].len > self.width then\
            str = str:sub( 1, #tabs[i].str + ( self.width - ( tabs[i].len + tabs[i].pos ) ) + 1 )\
        end\
        if tabs[i].pos > self.width then\
            str = \"\"\
        end\
        term.write( str )\
    end\
end )\
\
GUITabs:AddMethod( \"MouseEvent\", function( self, var, x, y, ev )\
    if ev.target == self and ev.type == \"Click\" then\
        local pos = x + var( \"get\", \"private\", \"tabOffset\" )\
        local m = 0\
        for i = 1,#self.tabs do\
            local str\
            local callback = self:GetCallback( \"FormatOption\" )\
            if callback then\
                str = tostring( callback( self, self.tabs[i], i ) )\
            else\
                str = tostring( self.tabs[i] )\
            end\
            if m + #str + 1 > pos then\
                if m ~= pos then\
                    local callback = self:GetCallback( \"OnSelect\" )\
                    if callback then\
                        callback( self, self.tabs[i], ev.button, i )\
                    end\
                end\
                break\
            end\
            m = m + #str + 1\
        end\
    end\
end )\
\
function GUITabs:Init( var, args )\
    var( \"set\", \"public\", \"backgroundColour\", New.Colour \"lightBlue\" )\
    var( \"set\", \"public\", \"tabColour\", New.Colour \"white\" )\
    var( \"set\", \"public\", \"textColour\", New.Colour \"black\" )\
    if type( args[5] ) == \"table\" then\
        self.tabs = args[5]\
    end\
end",
        ["GUIButton.class"] = "\
GUIButton:Extends( \"GUIText\" )\
\
GUIButton:AddVariable( \"alignment\", \"vcentre\", \"string\" )\
GUIButton:AddStaticVariable( \"MouseEvent\", function( self, x, y, ev )\
    if ev.target == self and ev.type == \"Click\" then\
        local callback = self:GetCallback( \"OnClick\" )\
        if callback then\
            callback( self, x, y, ev.button )\
        end\
    end\
end )\
\
function GUIButton:Describe( )\
    return \"GUI Button object\"\
end\
\
function GUIButton:Init( var, args )\
    if Class.CheckTypeOf( args[5], \"string\", \"String\" ) then\
        self.text = args[5]\
    end\
end",
        ["list.txt"] = "Colour\
FilesystemRedirect\
Filesystem\
GUIBase\
GUIFrame\
GUIText\
GUITextbox\
GUIInput\
GUIButton\
GUIField\
GUITabs\
GUICode\
Interface",
        ["Filesystem.class"] = "\
local readDir\
readDir = function( path )\
    local t = { }\
    local files = fs.list( path )\
    for i = 1,#files do\
        local data\
        if fs.isDir( path..\"/\"..files[i] ) then\
            data = readDir( path..\"/\"..files[i] )\
        else\
            local f = fs.open( path..\"/\"..files[i], \"r\" )\
            if f then\
                data = f.readAll( )\
                f.close( )\
            end\
        end\
        t[files[i]] = data\
    end\
    return t\
end\
\
local saveDir\
saveDir = function( path, t )\
    if not fs.isDir( path ) then\
        fs.makeDir( path )\
    end\
    for k, v in pairs( t ) do\
        if type( v ) == \"table\" then\
            saveDir( path..\"/\"..k, v )\
        else\
            local f = fs.open( path..\"/\"..k, \"w\" )\
            if f then\
                f.write( v )\
                f.close( )\
            end\
        end\
    end\
end\
\
local function readPath( path )\
    local folders = { }\
    local start, fin = path:find( \"%w+/\" )\
    local finish = 0\
    while start do\
        finish = fin\
        table.insert( folders, path:sub( start, fin - 1 ) )\
        start, fin = path:find( \"%w+/\", fin + 1 )\
    end\
    local name = path:sub( ( finish ) + 1 )\
    return name, folders\
end\
\
Filesystem:AddPrivateVariable( \"files\", { }, \"table\" )\
Filesystem:AddPrivateVariable( \"changed\", false, \"boolean\" )\
\
Filesystem:AddMethod( \"HasChanged\", function( self, var )\
    return var( \"get\", \"private\", \"changed\" )\
end )\
\
Filesystem:AddMethod( \"Open\", function( self, var, path, mode )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) or not Class.CheckTypeOf( mode, \"string\", \"String\" ) then\
        error( \"Expected string, string, got \"..type( path )..\", \"..type( mode ), 2 )\
    end\
    local name, folders = readPath( tostring( path ) )\
    local f = var( \"get\", \"private\", \"files\" )\
    for i = 1,#folders do\
        f[folders[i]] = f[folders[i]] or { }\
        f = f[folders[i]]\
    end\
    local open = true\
    local handle = { }\
    if tostring( mode ) == \"r\" then\
        if not f[name] then return end\
        local line = 0\
        local lines = { }\
        local start, fin = f[name]:find( \"\\n\" )\
        local finish = 0\
        while start do\
            table.insert( lines, f[name]:sub( finish, start - 1 ) )\
            finish = fin + 1\
            start, fin = f[name]:find( \"\\n\", fin + 1 )\
        end\
        table.insert( lines, f[name]:sub( finish + 1 ) )\
        handle.readLine = function( )\
            if not open then return end\
            line = line + 1\
            return lines[line]\
        end\
        handle.readAll = function( )\
            return open and f[name] or nil\
        end\
        handle.close = function( )\
            handle = { }\
            open = false\
        end\
    end\
    if tostring( mode ) == \"w\" then\
        local str = \"\"\
        handle.write = function( s )\
            if type( s ) ~= \"number\" and type( s ) ~= \"string\" then error( \"String expected, got \"..type( s ), 2 ) end\
            str = str .. s\
        end\
        handle.writeLine = function( s )\
            if type( s ) ~= \"number\" and type( s ) ~= \"string\" then error( \"String expected, got \"..type( s ), 2 ) end\
            str = str .. s .. \"\\n\"\
        end\
        handle.flush = function( )\
            var( \"set\", \"private\", \"changed\", true )\
            f[name] = str\
        end\
        handle.close = function( )\
            handle.flush( )\
            handle = { }\
            open = false\
        end\
    end\
    if tostring( mode ) == \"a\" then\
        local str = f[name]\
        handle.write = function( s )\
            if type( s ) ~= \"number\" and type( s ) ~= \"string\" then error( \"String expected, got \"..type( s ), 2 ) end\
            str = str .. s\
        end\
        handle.writeLine = function( s )\
            if type( s ) ~= \"number\" and type( s ) ~= \"string\" then error( \"String expected, got \"..type( s ), 2 ) end\
            str = str .. s .. \"\\n\"\
        end\
        handle.flush = function( )\
            var( \"set\", \"private\", \"changed\", true )\
            f[name] = str\
        end\
        handle.close = function( )\
            handle.flush( )\
            handle = { }\
            open = false\
        end\
    end\
    return handle\
end )\
\
Filesystem:AddMethod( \"NewDirectory\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    local name, folders = readPath( tostring( path ) )\
    local f = var( \"get\", \"private\", \"files\" )\
    for i = 1,#folders do\
        f[folders[i]] = f[folders[i]] or { }\
        f = f[folders[i]]\
    end\
    if type( f[name] ) == \"string\" then\
        error( \"File exists\", 2 )\
    end\
    var( \"set\", \"private\", \"changed\", true )\
    f[name] = f[name] or { }\
end )\
Filesystem:AddMethod( \"IsDirectory\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    local name, folders = readPath( tostring( path ) )\
    local f = var( \"get\", \"private\", \"files\" )\
    for i = 1,#folders do\
        if type( f[folders[i]] ) ~= \"table\" then\
            return false\
        end\
        f = f[folders[i]]\
    end\
    return type( f[name] ) == \"table\"\
end )\
Filesystem:AddMethod( \"Exists\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    local name, folders = readPath( tostring( path ) )\
    local f = var( \"get\", \"private\", \"files\" )\
    for i = 1,#folders do\
        if type( f[folders[i]] ) ~= \"table\" then\
            return false\
        end\
        f = f[folders[i]]\
    end\
    return not not f[name]\
end )\
Filesystem:AddMethod( \"List\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    local name, folders = readPath( tostring( path ) )\
    local f = var( \"get\", \"private\", \"files\" )\
    for i = 1,#folders do\
        if type( f[folders[i]] ) ~= \"table\" then\
            error( \"Not a directory\", 2 )\
        end\
        f = f[folders[i]]\
    end\
    if type( f[name] ) ~= \"table\" then\
        error( \"Not a directory\", 2 )\
    end\
    f = f[name]\
    local t = { }\
    for k, v in pairs( f ) do\
        table.insert( t, k )\
    end\
    return t\
end )\
\
Filesystem:AddMethod( \"Delete\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    local name, folders = readPath( tostring( path ) )\
    local f = var( \"get\", \"private\", \"files\" )\
    for i = 1,#folders do\
        if type( f[folders[i]] ) ~= \"table\" then\
            return\
        end\
        f = f[folders[i]]\
    end\
    var( \"set\", \"private\", \"changed\", true )\
    f[name] = nil\
end )\
Filesystem:AddMethod( \"Copy\", function( self, var, path1, path2 )\
    if not Class.CheckTypeOf( path1, \"string\", \"String\" ) or not Class.CheckTypeOf( path2, \"string\", \"String\" ) then\
        error( \"Expected string, string, got \"..type( path1 )..\", \"..type( path2 ), 2 )\
    end\
    if self:Exists( path2 ) then\
        error( \"File exists\", 2 )\
    end\
    local name, folders = readPath( tostring( path1 ) )\
    local str = \"\"\
    local f = var( \"get\", \"private\", \"files\" )\
    for i = 1,#folders do\
        if type( f[folders[i]] ) ~= \"table\" then\
            return false\
        end\
        f = f[folders[i]]\
    end\
    var( \"set\", \"private\", \"changed\", true )\
    local str = f[name]\
    local name, folders = readPath( tostring( path2 ) )\
    local f = var( \"get\", \"private\", \"files\" )\
    for i = 1,#folders do\
        f[folders[i]] = f[folders[i]] or { }\
        f = f[folders[i]]\
    end\
    var( \"set\", \"private\", \"changed\", true )\
    f[name] = str\
end )\
Filesystem:AddMethod( \"Move\", function( self, var, path1, path2 )\
    if not Class.CheckTypeOf( path1, \"string\", \"String\" ) or not Class.CheckTypeOf( path2, \"string\", \"String\" ) then\
        error( \"Expected string, string, got \"..type( path1 )..\", \"..type( path2 ), 2 )\
    end\
    self:copy( path1, path2 )\
    self:delete( path1 )\
end )\
\
Filesystem:AddMethod( \"Combine\", function( self, var, ... )\
    return fs.combine( ... )\
end )\
Filesystem:AddMethod( \"GetFreeSpace\", function( )\
    return math.huge\
end )\
Filesystem:AddMethod( \"GetDrive\", function( )\
    return \"vhd\"\
end )\
Filesystem:AddMethod( \"GetName\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    local name = readPath( tostring( path ) )\
    return name\
end )\
Filesystem:AddMethod( \"IsReadOnly\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return false\
end )\
Filesystem:AddMethod( \"GetSize\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return 0\
end )\
\
Filesystem:AddMethod( \"Redirect\", function( self, var )\
    local t = { }\
    for k, v in pairs( fs ) do\
        local method = k:sub( 1, 1 ):upper( )..k:sub( 2 )\
        t[k] = function( ... )\
            return self[method]( self, ... )\
        end\
    end\
    t.open = function( path, mode )\
        return self:Open( path, mode )\
    end\
    t.isDir = function( ... )\
        return self:IsDirectory( ... )\
    end\
    t.makeDir = function( ... )\
        return self:NewDirectory( ... )\
    end\
    t.find = function( ) end\
    return t\
end )\
\
Filesystem:AddMethod( \"Load\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    if not fs.isDir( tostring( path ) ) then\
        error( \"Not a directory\", 2 )\
    end\
    var( \"set\", \"private\", \"files\", readDir( tostring( path ) ) )\
    var( \"set\", \"private\", \"changed\", true )\
end )\
Filesystem:AddMethod( \"Save\", function( self, var, path, overwrite )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    if fs.exists( tostring( path ) ) and not overwrite then\
        error( \"File exists\", 2 )\
    end\
    saveDir( tostring( path ), var( \"get\", \"private\", \"files\" ) )\
    var( \"set\", \"private\", \"changed\", false )\
end )\
Filesystem:AddMethod( \"GetFiles\", function( self, var )\
    local clone\
    clone = function( t )\
        local tt = { }\
        for k, v in pairs( t ) do\
            if type( v ) == \"table\" then\
                tt[k] = clone( v )\
            else\
                tt[k] = v\
            end\
        end\
        return tt\
    end\
    return clone( var( \"get\", \"private\", \"files\" ) )\
end )\
\
function Filesystem:Init( var, args )\
    var( \"set\", \"private\", \"files\", { } )\
    if Class.CheckTypeOf( args[1], \"string\", \"String\" ) and fs.isDir( tostring( args[1] ) ) then\
        self:Load( tostring( args[1] ) )\
    elseif Class.CheckTypeOf( args[1], \"Package\" ) then\
        local files = args[1]:GetFiles( )\
        local ok, err = pcall( var, \"set\", \"private\", \"files\", files )\
        if not ok then\
            error( err, 2 )\
        end\
        var( \"set\", \"private\", \"loaded\", true )\
    end\
    var( \"set\", \"private\", \"changed\", false )\
end",
        ["GUICode.class"] = "\
local tabLength = 4\
local split = function( str, pat )\
    if type( str ) ~= \"string\" then error( \"Failed to split \"..type( str )..\" with \"..pat, 2 ) end\
    local parts = { }\
    local last = 1\
    for i = 1,str:len( ) do\
        if str:sub( i, i + #pat - 1 ) == pat then\
            table.insert( parts, str:sub( last, i-1 ) )\
            last = i + 1\
        end\
    end\
    if last <= #str then\
        table.insert( parts, str:sub( last, #str ) )\
    end\
    return parts\
end\
\
local function formatLine( line, syntax, bc, tc )\
    local line = string.gsub( line, \"  \", string.rep( \" \", tabLength ) )\
    local fline = { }\
    for i = 1,#line do\
        fline[i] = { char = line:sub( i, i ), bc = bc, tc = tc }\
    end\
    for k, v in pairs( syntax.words ) do\
        for ii = 1,#v do\
            local last = 1\
            local start, fin = string.find( line, v[ii].condition )\
            while start and fin do\
                local s, f = string.find( line:sub( start, fin ), k )\
                if s and f then\
                    for i = s + start - 1, f + start - 1 do\
                        if line:sub( i, i ) ~= \"(\" and line:sub( i, i ) ~= \")\" then\
                            fline[i] = { char = line:sub( i, i ), bc = bc, tc = v[ii].colour:Get( ) }\
                        end\
                    end\
                end\
                start, fin = string.find( line, k, fin + 1 )\
            end\
        end\
    end\
    local stringstarted = false\
    local startpos = 0\
    for i = 1,#line do\
        if ( line:sub( i, i ) == \"\\\"\" or line:sub( i, i ) == \"'\" ) and line:sub( i-1, i-1 ) ~= \"\\\\\" then\
            if stringstarted then\
                if line:sub( i, i ) == stringstarted then\
                    for ind = startpos, i do\
                        fline[ind] = { char = line:sub( ind, ind ), bc = bc, tc = syntax.stringColour:Get( ) }\
                    end\
                    stringstarted = false\
                end\
            else\
                stringstarted = line:sub( i, i )\
                startpos = i\
            end\
        end\
    end\
    for i = 1,#line do\
        if line:sub( i, i + 1 ) == \"--\" then\
            for ind = i, #line do\
                fline[ind] = { char = line:sub( ind, ind ), bc = bc, tc = syntax.commentColour:Get( ) }\
            end\
        end\
    end\
    return fline\
end\
\
local function renderLine( f, x, y, w, xoffset )\
    for i = 1,xoffset do\
        table.remove( f, 1 )\
    end\
    for i = -1, xoffset, -1 do\
        table.insert( f, 1, { char = \" \", bc = 32768, tc = 1 } )\
    end\
    local start = 1\
    if not f[1] then return 0 end\
    local text = f[1].char\
    local bc = f[1].bc\
    local tc = f[1].tc\
    for i = 2, #f do\
        if start > w then return end\
        if f[i].bc == bc and f[i].tc == tc then\
            text = text..f[i].char\
        else\
            if start + x - 1 < 1 then\
                if start + #text > 1 then\
                    text = text:sub( - (start + x - 1) )\
                    start = 1\
                end\
            end\
            if start + x - 1 >= 1 then\
                term.setCursorPos( start + x - 1, y )\
                term.setBackgroundColour( bc )\
                term.setTextColour( tc )\
                if start + #text > w then\
                    term.write( text:sub( 1, w - start + 1 ) )\
                    return w\
                end\
                term.write( text )\
            end\
            text = f[i].char\
            bc = f[i].bc\
            tc = f[i].tc\
            start = i\
        end\
    end\
    if start + #text > w then\
        text = text:sub( 1, w - start + 1 )\
    end\
    term.setCursorPos( x + start - 1, y )\
    term.setBackgroundColour( bc )\
    term.setTextColour( tc )\
    term.write( text )\
    return #f\
end\
\
GUICode:Extends( \"GUIBase\" )\
GUICode:AddVariable( \"cursorX\", 1, \"number\" )\
GUICode:AddVariable( \"cursorY\", 1, \"number\" )\
GUICode:AddVariable( \"backgroundColour\", \"\", \"Colour\" )\
GUICode:AddVariable( \"lineColour\", \"\", \"Colour\" )\
GUICode:AddVariable( \"textColour\", \"\", \"Colour\" )\
\
GUICode:AddPrivateVariable( \"scrollX\", 0, \"number\" )\
GUICode:AddPrivateVariable( \"scrollY\", 0, \"number\" )\
GUICode:AddPrivateVariable( \"syntax\", { }, \"table\" )\
GUICode:AddPrivateVariable( \"lines\", { }, \"table\" )\
GUICode:AddPrivateVariable( \"focussed\", false, \"boolean\" )\
\
GUICode:AddMethod( \"SetCommentColour\", function( self, var, col )\
    if Class.CheckTypeOf( col, \"Colour\" ) then\
        var( \"get\", \"private\", \"syntax\" ).commentColour = col\
        return\
    end\
    error( \"Expected Colour, got \"..type( col ), 2 )\
end )\
GUICode:AddMethod( \"GetCommentColour\", function( self, var )\
    return var( \"get\", \"private\", \"syntax\" ).commentColour\
end )\
\
GUICode:AddMethod( \"SetStringColour\", function( self, var, col )\
    if Class.CheckTypeOf( col, \"Colour\" ) then\
        var( \"get\", \"private\", \"syntax\" ).stringColour = col\
        return\
    end\
    error( \"Expected Colour, got \"..type( col ), 2 )\
end )\
GUICode:AddMethod( \"GetStringColour\", function( self, var )\
    return var( \"get\", \"private\", \"syntax\" ).stringColour\
end )\
\
GUICode:AddMethod( \"SetWordColour\", function( self, var, word, col, condition )\
    if Class.CheckTypeOf( col, \"Colour\" ) then\
        condition = condition or word\
        local s = var( \"get\", \"private\", \"syntax\" )\
        s.words[word] = s.words[word] or { }\
        table.insert( s.words[word], { condition = condition, colour = col } )\
        return\
    end\
    error( \"Expected Colour, got \"..type( col ), 2 )\
end )\
\
GUICode:AddMethod( \"SetLines\", function( self, var, lines )\
    if type( lines ) == \"table\" then\
        local l = { }\
        for i = 1,#lines do\
            l[i] = tostring( lines[i] )\
        end\
        var( \"set\", \"private\", \"lines\", l )\
        return\
    end\
    error( \"Expected table, got \"..type( lines ), 2 )\
end )\
GUICode:AddMethod( \"GetLines\", function( self, var )\
    return var( \"get\", \"private\", \"lines\" )\
end )\
\
GUICode:AddMethod( \"SetText\", function( self, var, str )\
    if Class.CheckTypeOf( str, \"string\", \"String\" ) then\
        return self:SetLines( split( tostring( str ), \"\\n\" ) )\
    end\
    error( \"Expected string, got \"..type( str ), 2 )\
end )\
GUICode:AddMethod( \"GetText\", function( self, var )\
    return table.concat( var( \"get\", \"private\", \"lines\" ), \"\\n\" )\
end )\
\
GUICode:AddMethod( \"GetDisplayedLineNumber\", function( self, var, y )\
    return y + var( \"get\", \"private\", \"scrollY\" )\
end )\
\
GUICode:AddMethod( \"UseLuaSyntax\", function( self, var )\
        local keywords = {\
            \"while\";\
            \"for\";\
            \"true\";\
            \"false\";\
            \"do\";\
            \"if\";\
            \"else\";\
            \"elseif\";\
            \"then\";\
            \"end\";\
            \"not\";\
            \"local\";\
            \"break\";\
            \"function\"\
        }\
        local kcol = New.Colour \"blue\"\
        for i = 1,#keywords do\
            self:SetWordColour( \"%s\"..keywords[i]..\"%s\", kcol )\
            self:SetWordColour( \"%s\"..keywords[i]..\"$\", kcol )\
            self:SetWordColour( \"^\"..keywords[i]..\"%s\", kcol )\
            self:SetWordColour( \"^\"..keywords[i]..\"$\", kcol )\
        end\
\
        local functions = {\
            \"tostring\";\
            \"tonumber\";\
            \"pairs\";\
            \"ipairs\";\
            \"print\";\
            \"write\";\
            \"setmetatable\";\
            \"getmetatable\";\
            \"setfenv\";\
            \"getfenv\";\
        }\
        local fcol = New.Colour \"cyan\"\
        for i = 1,#functions do\
            self:SetWordColour( functions[i], fcol, \"%s\"..functions[i]..\"%s*%(.*%)\" )\
            self:SetWordColour( functions[i], fcol, \"^\"..functions[i]..\"%s*%(.*%)\" )\
        end\
\
        local tables = {\
            \"string\";\
            \"table\";\
            \"math\";\
        }\
        local tcol = New.Colour \"purple\"\
        for i = 1,#tables do\
            self:SetWordColour( \"%s\"..tables[i]..\"%.%w+\", tcol )\
            self:SetWordColour( \"%s\"..tables[i]..\"%.\", tcol )\
            self:SetWordColour( \"^\"..tables[i]..\"%.%w+\", tcol )\
            self:SetWordColour( \"^\"..tables[i]..\"%.\", tcol )\
        end\
\
        local words = {\
            [\"{\"] = New.Colour \"lightBlue\";\
            [\"}\"] = New.Colour \"lightBlue\";\
            [\"%[\"] = New.Colour \"lightBlue\";\
            [\"%]\"] = New.Colour \"lightBlue\";\
            [\"%d\"] = New.Colour \"orange\";\
            [\"easter egg\"] = New.Colour \"lime\";\
        }\
        for k, v in pairs( words ) do\
            self:SetWordColour( k, v )\
        end\
        self:SetWordColour( \"error\", New.Colour \"red\", \"error%s*%(.*%)\" )\
        self:SetWordColour( \"#%w+\", New.Colour \"lightBlue\", \"#%w+\" )\
end )\
\
GUICode:AddMethod( \"SetCursorPos\", function( self, var, x, y, scroll )\
    local lines = var( \"get\", \"private\", \"lines\" )\
    if lines[y] then\
        var( \"set\", \"public\", \"cursorX\", math.max( math.min( x, #lines[y] + 1 ), 1 ) )\
        var( \"set\", \"public\", \"cursorY\", y )\
    else\
        if y < 1 then\
            var( \"set\", \"public\", \"cursorX\", 1 )\
            var( \"set\", \"public\", \"cursorY\", 1 )\
        else\
            var( \"set\", \"public\", \"cursorX\", #( lines[#lines] or { } ) + 1 )\
            var( \"set\", \"public\", \"cursorY\", math.max( #lines, 1 ) )\
        end\
    end\
    if scroll then\
        local dist = 0\
        local x, y = var( \"get\", \"public\", \"cursorX\" ), var( \"get\", \"public\", \"cursorY\" )\
        local xs, ys = var( \"get\", \"private\", \"scrollX\" ), var( \"get\", \"private\", \"scrollY\" )\
        for i = 1,x-1 do\
            dist = dist + ( lines[y]:sub( i, i ) == \"  \" and tabLength or 1 )\
        end\
        if dist < xs + 1 then\
            var( \"set\", \"private\", \"scrollX\", math.max( dist - 1, 0 ) )\
        elseif dist + 1 > xs + self.width then\
            var( \"set\", \"private\", \"scrollX\", dist + 1 - self.width )\
        end\
        if y <= ys then\
            var( \"set\", \"private\", \"scrollY\", y - 1 )\
        elseif y > ys + self.height then\
            var( \"set\", \"private\", \"scrollY\", y - self.height )\
        end\
    end\
end )\
\
GUICode:AddMethod( \"Render\", function( self, var, x, y )\
    local lines = var( \"get\", \"private\", \"lines\" )\
    for i = 1,self.height do\
        local line = i + var( \"get\", \"private\", \"scrollY\" )\
        if lines[line] then\
            local bc = ( line == var( \"get\", \"public\", \"cursorY\" ) and var( \"get\", \"private\", \"focussed\" ) ) and var( \"get\", \"public\", \"lineColour\" ):Get( ) or var( \"get\", \"public\", \"backgroundColour\" ):Get( )\
            \
            local fline = formatLine( lines[line], var( \"get\", \"private\", \"syntax\" ), bc, var( \"get\", \"public\", \"textColour\" ):Get( ) )\
            local length = renderLine( fline, x, y + i - 1, self.width, var( \"get\", \"private\", \"scrollX\" ) )\
            if length < self.width then\
                term.setCursorPos( x + length, y + i - 1 )\
                term.setBackgroundColour( bc )\
                term.write( string.rep( \" \", self.width - length ) )\
            end\
        else\
            term.setCursorPos( x, y + i - 1 )\
            term.setBackgroundColour( var( \"get\", \"public\", \"backgroundColour\" ):Get( ) )\
            term.write( string.rep( \" \", self.width ) )\
        end\
    end\
    if self.active and var( \"get\", \"private\", \"focussed\" ) then\
        local xx, yy = var( \"get\", \"public\", \"cursorX\" ), var( \"get\", \"public\", \"cursorY\" )\
        local line = lines[yy]\
        local pos = 0\
        for i = 1,xx - 1 do\
            if line:sub( i, i ) == \"   \" then\
                pos = pos + tabLength\
            else\
                pos = pos + 1\
            end\
        end\
        self:RequestCursorBlink( x + ( pos + 1 - var( \"get\", \"private\", \"scrollX\" ) ) - 1, y + ( yy - var( \"get\", \"private\", \"scrollY\" ) ) - 1, var( \"get\", \"public\", \"textColour\" ):Get( ) )\
    end\
end )\
\
GUICode:AddMethod( \"MouseEvent\", function( self, var, x, y, ev )\
    if ev.target == self then\
        self:FocusOn( )\
        if ev.type == \"Click\" then\
            var( \"set\", \"private\", \"focussed\", true )\
            local lines = var( \"get\", \"private\", \"lines\" )\
            local line = tostring( lines[y+var( \"get\", \"private\", \"scrollY\" )] )\
            local max = #string.gsub( line, \"  \", string.rep( \" \", tabLength ) )\
            if x + var( \"get\", \"private\", \"scrollX\" ) > max then\
                self:SetCursorPos( max + 1, y + var( \"get\", \"private\", \"scrollY\", true ) )\
                return\
            end\
            local pos = -var( \"get\", \"private\", \"scrollX\" )\
            local rpos = 0\
            for i = 1,#line do\
                pos = pos + ( line:sub( i, i ) == \"    \" and tabLength or 1 )\
                rpos = rpos + 1\
                if pos >= x then\
                    break\
                end\
            end\
            self:SetCursorPos( rpos, y + var( \"get\", \"private\", \"scrollY\" ), true )\
        elseif ev.type == \"Scroll\" then\
            local s = var( \"get\", \"private\", \"scrollY\" )\
            var( \"set\", \"private\", \"scrollY\", math.max( math.min( s - ev.button, #var( \"get\", \"private\", \"lines\" ) - self.height ), 0 ) )\
        end\
    else\
        var( \"set\", \"private\", \"focussed\", false )\
    end\
end )\
\
GUICode:AddMethod( \"handlesKeyboard\", function( self, var )\
    return var( \"get\", \"private\", \"focussed\" )\
end )\
\
GUICode:AddMethod( \"Event\", function( self, var, ev )\
    if ev[1] == \"Keyboard\" and ev[5] == self and var( \"get\", \"private\", \"focussed\" ) then\
        local x, y = var( \"get\", \"public\", \"cursorX\" ), var( \"get\", \"public\", \"cursorY\" )\
        local lines = var( \"get\", \"private\", \"lines\" )\
        local xs, ys = var( \"get\", \"private\", \"scrollX\" ), var( \"get\", \"private\", \"scrollY\" )\
        if ev[3] == \"up\" then\
            self:SetCursorPos( x, y - 1, true )\
        elseif ev[3] == \"down\" then\
            self:SetCursorPos( x, y + 1, true )\
        elseif ev[3] == \"left\" then\
            self:SetCursorPos( x - 1, y, true )\
        elseif ev[3] == \"right\" then\
            self:SetCursorPos( x + 1, y, true )\
        elseif ev[3] == \"tab\" then\
            lines[y] = lines[y]:sub( 1, x - 1 )..\" \"..lines[y]:sub( x )\
            self:SetCursorPos( x + 1, y, true )\
        elseif ev[3] == \"backspace\" then\
            if x == 1 then\
                if y > 1 then\
                    self:SetCursorPos( #lines[y-1]+1, y-1, true )\
                    lines[y-1] = lines[y-1]..lines[y]\
                    table.remove( lines, y )\
                end\
            else\
                lines[y] = lines[y]:sub( 1, x-2 )..lines[y]:sub( x )\
                self:SetCursorPos( x - 1, y, true )\
            end\
        elseif ev[3] == \"enter\" then\
            table.insert( lines, y + 1, lines[y]:sub( x ) )\
            lines[y] = lines[y]:sub( 1, x - 1 )\
            if #lines[y+1] ~= 0 then\
                self:SetCursorPos( 1, y + 1, true )\
                return \
            end\
            local tabcount = 0\
            for i = 1,#lines[y] do\
                if lines[y]:sub( i, i ) == \"   \" then\
                    tabcount = tabcount + 1\
                else\
                    break\
                end\
            end\
            lines[y+1] = string.rep( \" \", tabcount )..lines[y+1]\
            self:SetCursorPos( tabcount + 1, y + 1, true )\
        elseif ev[3] == \"delete\" then\
            if x == #lines[y] + 1 then\
                lines[y] = lines[y]..( lines[y+1] or \"\" )\
                table.remove( lines, y + 1 )\
            else\
                lines[y] = lines[y]:sub( 1, x - 1 )..lines[y]:sub( x + 1 )\
            end\
        elseif ev[2] then\
            lines[y] = ( lines[y] or \"\" ):sub( 1, x - 1 )..ev[3]..( lines[y] or \"\" ):sub( x )\
            self:SetCursorPos( x + 1, y, true )\
        end\
    end\
end )\
\
function GUICode:Init( var, args )\
    var( \"set\", \"private\", \"syntax\", {\
        words = { };\
        stringColour = New.Colour \"lightGrey\";\
        commentColour = New.Colour \"green\";\
    } )\
    var( \"set\", \"private\", \"lines\", { } )\
    var( \"set\", \"public\", \"lineColour\", New.Colour \"black\" )\
    var( \"set\", \"public\", \"backgroundColour\", New.Colour \"black\" )\
    var( \"set\", \"public\", \"textColour\", New.Colour \"white\" )\
    if type( args[5] ) == \"table\" then\
        self:SetLines( args[5] )\
    elseif Class.CheckTypeOf( args[5], \"string\", \"String\" ) then\
        self:SetText( tostring( args[5] ) )\
    end\
end",
        ["FilesystemRedirect.class"] = "\
FilesystemRedirect:AddPrivateVariable( \"path\", \"\", \"string\", \"String\" )\
FilesystemRedirect:AddPrivateVariable( \"allowRomAccess\", false, \"boolean\" )\
\
FilesystemRedirect:AddMethod( \"SetRomAccess\", function( self, var, value )\
    var( \"set\", \"private\", \"allowRomAccess\", not not value )\
end )\
\
FilesystemRedirect:AddMethod( \"GetPath\", function( self, var, path )\
    if path and path:find( \"^rom/\" ) then\
        return \"\"\
    end\
    return var( \"get\", \"private\", \"path\" )\
end )\
FilesystemRedirect:AddMethod( \"SetPath\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    var( \"set\", \"private\", \"path\", path )\
end )\
\
FilesystemRedirect:AddPrivateMethod( \"GetPath\", function( self, var, path )\
    if path and path:find( \"^rom/\" ) then\
        return \"\"\
    end\
    return tostring( var( \"get\", \"private\", \"path\" ) )\
end )\
FilesystemRedirect:AddPrivateMethod( \"FormatPath\", function( self, var, path )\
    return fs.combine( var( \"call\", \"pmethod\", \"GetPath\", path ), path )\
end )\
\
FilesystemRedirect:AddMethod( \"Open\", function( self, var, path, mode )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) or not Class.CheckTypeOf( mode, \"string\", \"String\" ) then\
        error( \"Expected string, string, got \"..type( path )..\", \"..type( mode ), 2 )\
    end\
    return fs.open( var( \"call\", \"pmethod\", \"FormatPath\", path ), mode )\
end )\
\
FilesystemRedirect:AddMethod( \"NewDirectory\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.makeDir( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
FilesystemRedirect:AddMethod( \"IsDirectory\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.isDir( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
FilesystemRedirect:AddMethod( \"Exists\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.exists( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
FilesystemRedirect:AddMethod( \"List\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.list( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
\
FilesystemRedirect:AddMethod( \"Delete\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.delete( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
FilesystemRedirect:AddMethod( \"Copy\", function( self, var, path1, path2 )\
    if not Class.CheckTypeOf( path1, \"string\", \"String\" ) or not Class.CheckTypeOf( path2, \"string\", \"String\" ) then\
        error( \"Expected string, string, got \"..type( path1 )..\", \"..type( path2 ), 2 )\
    end\
    return fs.copy( var( \"call\", \"pmethod\", \"FormatPath\", path1 ), var( \"call\", \"pmethod\", \"FormatPath\", path2 ) )\
end )\
FilesystemRedirect:AddMethod( \"Move\", function( self, var, path1, path2 )\
    if not Class.CheckTypeOf( path1, \"string\", \"String\" ) or not Class.CheckTypeOf( path2, \"string\", \"String\" ) then\
        error( \"Expected string, string, got \"..type( path1 )..\", \"..type( path2 ), 2 )\
    end\
    return fs.copy( var( \"call\", \"pmethod\", \"FormatPath\", path1 ), var( \"call\", \"pmethod\", \"FormatPath\", path2 ) )\
end )\
\
FilesystemRedirect:AddMethod( \"Combine\", function( self, var, ... )\
    return fs.combine( ... )\
end )\
FilesystemRedirect:AddMethod( \"GetFreeSpace\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.getFreeSpace( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
FilesystemRedirect:AddMethod( \"GetDrive\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.getDrive( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
FilesystemRedirect:AddMethod( \"GetName\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.getName( path )\
end )\
FilesystemRedirect:AddMethod( \"IsReadOnly\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.isReadOnly( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
FilesystemRedirect:AddMethod( \"GetSize\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.getSize( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
FilesystemRedirect:AddMethod( \"Find\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    return fs.find( var( \"call\", \"pmethod\", \"FormatPath\", path ) )\
end )\
\
FilesystemRedirect:AddMethod( \"Redirect\", function( self, var )\
    local t = { }\
    for k, v in pairs( fs ) do\
        local method = k:sub( 1, 1 ):upper( )..k:sub( 2 )\
        t[k] = function( ... )\
            return self[method]( self, ... )\
        end\
    end\
    t.open = function( path, mode )\
        return self:Open( path, mode )\
    end\
    t.isDir = function( ... )\
        return self:IsDirectory( ... )\
    end\
    t.makeDir = function( ... )\
        return self:NewDirectory( ... )\
    end\
    return t\
end )\
\
FilesystemRedirect:AddMethod( \"Load\", function( self, var, path )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    if not fs.isDir( tostring( path ) ) then\
        error( \"Not a directory\", 2 )\
    end\
    var( \"set\", \"private\", \"files\", readDir( tostring( path ) ) )\
    var( \"set\", \"private\", \"changed\", true )\
end )\
FilesystemRedirect:AddMethod( \"Save\", function( self, var, path, overwrite )\
    if not Class.CheckTypeOf( path, \"string\", \"String\" ) then\
        error( \"Expected string, got \"..type( path ), 2 )\
    end\
    if fs.exists( tostring( path ) ) and not overwrite then\
        error( \"File exists\", 2 )\
    end\
    saveDir( tostring( path ), var( \"get\", \"private\", \"files\" ) )\
    var( \"set\", \"private\", \"changed\", false )\
end )\
FilesystemRedirect:AddMethod( \"GetFiles\", function( self, var )\
    local clone\
    clone = function( t )\
        local tt = { }\
        for k, v in pairs( t ) do\
            if type( v ) == \"table\" then\
                tt[k] = clone( v )\
            else\
                tt[k] = v\
            end\
        end\
        return tt\
    end\
    return clone( var( \"get\", \"private\", \"files\" ) )\
end )\
\
function FilesystemRedirect:Describe( var )\
    local path = var( \"get\", \"private\", \"path\" )\
    if path then\
        return \"Filesystem: \"..tostring( path )\
    else\
        return \"Filesystem Redirect\"\
    end\
end\
\
function FilesystemRedirect:Init( var, args )\
    if Class.CheckTypeOf( args[1], \"string\", \"String\" ) and fs.isDir( tostring( args[1] ) ) then\
        var( \"set\", \"private\", \"path\", args[1] )\
    end\
end",
        ["GUITextbox.class"] = "\
GUITextbox:Extends( \"GUIText\" )\
\
GUITextbox:AddVariable( \"focussedBackgroundColour\", New.Colour( \"white\" ), \"Colour\" )\
GUITextbox:AddVariable( \"focussedTextColour\", New.Colour( \"black\" ), \"Colour\" )\
GUITextbox:AddVariable( \"highlightBackgroundColour\", New.Colour( \"blue\" ), \"Colour\" )\
GUITextbox:AddVariable( \"highlightTextColour\", New.Colour( \"black\" ), \"Colour\" )\
GUITextbox:AddVariable( \"inputmode\", \"set\", \"string\", \"String\" )\
GUITextbox:AddVariable( \"canHighlight\", true, \"boolean\" )\
\
GUITextbox:AddStaticVariable( \"cursorPos\", 1, \"number\" )\
GUITextbox:AddPrivateVariable( \"focussed\", false, \"boolean\" )\
GUITextbox:AddPrivateVariable( \"highlight\", { }, \"table\" )\
\
GUITextbox:AddMethod( \"GetHighlightedText\", function( self, var )\
    local highlight = var( \"get\", \"private\", \"highlight\" )\
    if highlight.current then\
        local hpos1, hpos2 = math.min( var( \"get\", \"private\", \"highlight\" ).pos, self.cursorPos ), math.max( var( \"get\", \"private\", \"highlight\" ).pos, self.cursorPos )\
        return table.concat( self:GetLines( ), \"\" ):sub( hpos1, hpos2 + 1 )\
    end\
    return false\
end )\
\
GUITextbox:AddMethod( \"handlesKeyboard\", function( self, var )\
    return var( \"get\", \"private\", \"focussed\" )\
end )\
\
GUITextbox:AddMethod( \"MouseEvent\", function( self, var, x, y, ev )\
    if ev.target == self and ev.type == \"Click\" then\
        local callback = self:GetCallback( \"OnFocus\" )\
        if callback then\
            callback( self, x, y, ev.button )\
        end\
        local pos = var( \"call\", \"pmethod\", \"GetClickPosition\", x, y )\
        var( \"set\", \"static\", \"cursorPos\", pos )\
        var( \"set\", \"private\", \"focussed\", true )\
        var( \"set\", \"private\", \"highlight\", { current = false, pos = 1 } )\
        self:FocusOn( )\
    elseif ev.target == self and ev.type == \"Drag\" and self.canHighlight then\
        local pos = var( \"call\", \"pmethod\", \"GetClickPosition\", math.min( math.max( x, 1 ), self.width ), math.min( math.max( y, 1 ), self.height ) )\
        var( \"set\", \"private\", \"highlight\", { current = true, pos = pos } )\
        self:FocusOn( )\
    elseif ev.type == \"Click\" then\
        var( \"set\", \"private\", \"focussed\", false )\
    end\
end )\
GUITextbox:AddMethod( \"Event\", function( self, var, ev )\
    if ev[1] == \"Keyboard\" and ev[5] == self and var( \"get\", \"private\", \"focussed\" ) then\
        local oldtext = self:GetText( )\
        local oldpos = self.cursorPos\
        if self.inputmode == \"add\" then\
            var( \"set\", \"static\", \"cursorPos\", #oldtext + 1 )\
        end\
        if ev[2] then -- it was a char press\
            self.text = oldtext:sub( 1, oldpos - 1 )..ev[3]..oldtext:sub( oldpos )\
            var( \"set\", \"static\", \"cursorPos\", self.cursorPos + 1 )\
        else\
            if ev[3] == \"enter\" then\
                local callback = self:GetCallback( \"KeyPressEnter\" )\
                if callback then\
                    callback( self )\
                else\
                    var( \"set\", \"private\", \"focussed\", false )\
                end\
            elseif ev[3] == \"tab\" then\
                local callback = self:GetCallback( \"KeyPressTab\" )\
                if callback then\
                    callback( self )\
                else\
                    var( \"set\", \"private\", \"focussed\", false )\
                end\
            elseif ev[3] == \"backspace\" then\
                local callback = self:GetCallback( \"KeyPressBackspace\" )\
                if callback then\
                    callback( self )\
                elseif self.cursorPos > 1 then\
                    self.text = oldtext:sub( 1, oldpos - 2 )..oldtext:sub( oldpos )\
                    var( \"set\", \"static\", \"cursorPos\", math.max( self.cursorPos - 1, 1 ) )\
                end\
            elseif ev[3] == \"left\" then\
                local callback = self:GetCallback( \"KeyPressLeft\" )\
                if callback then\
                    callback( self )\
                else\
                    var( \"set\", \"static\", \"cursorPos\", math.max( 1, self.cursorPos - 1 ) )\
                end\
            elseif ev[3] == \"right\" then\
                local callback = self:GetCallback( \"KeyPressRight\" )\
                if callback then\
                    callback( self )\
                else\
                    var( \"set\", \"static\", \"cursorPos\", math.min( #oldtext + 1, self.cursorPos + 1 ) )\
                end\
            elseif ev[3] == \"delete\" then\
                local callback = self:GetCallback( \"KeyPressDelete\" )\
                if callback then\
                    callback( self )\
                else\
                    self.text = oldtext:sub( 1, oldpos - 1 )..oldtext:sub( oldpos + 1 )\
                end\
            end\
        end\
        self:UpdateLines( )\
        local lines = var( \"get\", \"private\", \"lines\" )\
        local l = self.height\
        if #lines > l or ( lines[l] and #lines[l] == self.width ) then\
            self.text = oldtext\
            var( \"set\", \"static\", \"cursorPos\", oldpos )\
        end\
    end\
end )\
\
GUITextbox:AddMethod( \"Render\", function( self, var, x, y )\
    local width = self.width\
    local height = self.height\
    local lines = self:GetLines( )\
    local hx1, hx2, hy1, hy2\
    if var( \"get\", \"private\", \"highlight\" ).current then\
        local hpos1, hpos2 = math.min( var( \"get\", \"private\", \"highlight\" ).pos, self.cursorPos ), math.max( var( \"get\", \"private\", \"highlight\" ).pos, self.cursorPos )\
        hx1, hy1 = var( \"call\", \"pmethod\", \"GetCursorPosition\", hpos1 )\
        hx2, hy2 = var( \"call\", \"pmethod\", \"GetCursorPosition\", hpos2 )\
    end\
    if var( \"get\", \"private\", \"focussed\" ) then\
        term.setBackgroundColour( self.focussedBackgroundColour:Get( ) )\
        term.setTextColour( self.focussedTextColour:Get( ) )\
    else\
        term.setBackgroundColour( self.backgroundColour:Get( ) )\
        term.setTextColour( self.textColour:Get( ) )\
    end\
    local yoffset = self:GetYOffset( )\
    for i = 1,height do\
        local offset = self:GetLineOffset( lines[i-yoffset] or \"\" )\
        if i == hy1 then\
            if i == hy2 then\
                local l = ( lines[i-yoffset] or \"\" ):sub( 1, self.width )\
                local part1, part2, part3 = l:sub( 1, hx1 - 1 ), l:sub( hx1, hx2 ), l:sub( hx2 + 1 )\
                local o = string.rep( \" \", offset )\
                local line = o..( lines[i-yoffset] or \"\" )\
                term.setCursorPos( x, y + i - 1 )\
                term.write( o..part1 )\
                term.setBackgroundColour( self.highlightBackgroundColour:Get( ) )\
                term.setTextColour( self.highlightTextColour:Get( ) )\
                term.write( part2 )\
                term.setBackgroundColour( self.backgroundColour:Get( ) )\
                term.setTextColour( self.textColour:Get( ) )\
                term.write( part3 )\
                if #line < self.width then\
                    term.write( string.rep( \" \", self.width - #line ) )\
                end\
            else\
                local l = ( lines[i-yoffset] or \"\" ):sub( 1, self.width )\
                local part1, part2 = l:sub( 1, hx1 - 1 ), l:sub( hx1 )\
                local o = string.rep( \" \", offset )\
                local line = o..( lines[i-yoffset] or \"\" )\
                term.setCursorPos( x, y + i - 1 )\
                term.write( o..part1 )\
                term.setBackgroundColour( self.highlightBackgroundColour:Get( ) )\
                term.setTextColour( self.highlightTextColour:Get( ) )\
                term.write( part2 )\
                if #line < self.width then\
                    term.write( string.rep( \" \", self.width - #line ) )\
                end\
                term.setBackgroundColour( self.backgroundColour:Get( ) )\
                term.setTextColour( self.textColour:Get( ) )\
            end\
        elseif i == hy2 then\
            local l = ( lines[i-yoffset] or \"\" ):sub( 1, self.width )\
            local part1, part2 = l:sub( 1, hx2 ), l:sub( hx2 + 1 )\
            local o = string.rep( \" \", offset )\
            local line = o..( lines[i-yoffset] or \"\" )\
            term.setCursorPos( x, y + i - 1 )\
            term.setBackgroundColour( self.highlightBackgroundColour:Get( ) )\
            term.setTextColour( self.highlightTextColour:Get( ) )\
            term.write( o..part1 )\
            term.setBackgroundColour( self.backgroundColour:Get( ) )\
            term.setTextColour( self.textColour:Get( ) )\
            term.write( part2 )\
            if #line < self.width then\
                term.write( string.rep( \" \", self.width - #line ) )\
            end\
        else\
            local line = string.rep( \" \", offset )..( lines[i-yoffset] or \"\" )\
            term.setCursorPos( x, y + i - 1 )\
            term.write( line:sub( 1, self.width ) )\
            if #line < self.width then\
                term.write( string.rep( \" \", self.width - #line ) )\
            end\
        end\
    end\
    if self.active and var( \"get\", \"private\", \"focussed\" ) then\
        local xx, yy = var( \"call\", \"pmethod\", \"GetCursorPosition\", self.cursorPos )\
        self:RequestCursorBlink( x + xx - 1, y + yy - 1, self.focussedBackgroundColour:Get( ) == 1 and 32768 or 1 )\
    end\
end )\
\
function GUITextbox:Init( var, args )\
    var( \"set\", \"public\", \"focussedBackgroundColour\", New.Colour( \"white\" ) )\
    var( \"set\", \"public\", \"focussedTextColour\", New.Colour( \"black\" ) )\
    var( \"set\", \"public\", \"highlightBackgroundColour\", New.Colour( \"blue\" ) )\
    var( \"set\", \"public\", \"highlightTextColour\", New.Colour( \"white\" ) )\
    var( \"set\", \"private\", \"highlight\", {\
        pos = 1;\
        current = false;\
    } )\
end",
        ["GUIField.class"] = "\
GUIField:Extends( \"GUIBase\" )\
\
GUIField:AddVariable( \"colour\", New.Colour \"white\", \"Colour\" )\
\
GUIField:AddMethod( \"Render\", function( self, var, x, y )\
    term.setBackgroundColour( self.colour:Get( ) )\
    for i = 1, self.height do\
        term.setCursorPos( x, y + i - 1 )\
        term.write( string.rep( \" \", self.width ) )\
    end\
end )\
\
function GUIField:Describe( )\
    return \"GUI Field object\"\
end\
\
function GUIField:Init( var, args )\
    if Class.CheckType( args[5], \"Colour\" ) then\
        self.colour:Set( args[5]:Get( ) )\
    elseif type( args[5] ) == \"string\" or type( args[5] ) == \"number\" then\
        self.colour:Set( args[5] )\
    end\
end",
    },
    uclass =    {
        Package = "",
        Filesystem = "",
        FilesystemRedirect = "",
    },
    ["NovaProgram.txt"] = "This program was made with Nova Utilities!\
Credits to awsumben13 for writing Nova Utilities.\
You can find Nova on the forums at: (coming soon).\
\
Please do not delete this file.",
    ["main.conf"] = "",
    ["class.lua"] = "\
--[[\
    #====# Awsumben13s Class System #====#\
    #====# Creator: Benedict Allen  #====#\
    \
        Feel free to use and modify this software with the following conditions:\
            1) Keep this section at the top of the code, completely unmodified.\
            2) If you make any modifications, make it clear\
                a) That you are not using the original software.\
                b) What you have changed.\
            3) Include credits to the author where necessary.\
            4) Do not use this to make malicious software.\
            \
        Thank you for using this.\
]]\
\
local classes = { }\
\
local Class = { }\
Class.New = function( name, data )\
    if type( name ) ~= \"string\" then return error( \"Name expected as first argument, got \"..type( name ), 2 ) end\
    local cls = { }\
    cls.name = name\
    cls.parent = false\
    cls.privateVariables = { }\
    cls.privateMethods = { }\
    cls.staticVariables = { }\
    cls.methods = { }\
    cls.publicVariables = { }\
    \
    if data then\
        cls.privateMethods = data.privateMethods or { }\
        cls.privateVariables = data.privateVariables or { }\
        cls.staticVariables = data.staticVariables or { }\
        cls.methods = data.methods or { }\
        cls.publicVariables = data.publicVariables or { }\
    end\
    \
    function cls:Extends( class )\
        if type( class ) == \"string\" then\
            class = classes[class]\
        end\
        if type( class ) == \"table\" then\
            self.parent = class\
            setmetatable( self.privateVariables, { __index = class.privateVariables } )\
            setmetatable( self.privateMethods, { __index = class.privateMethods } )\
            setmetatable( self.staticVariables, { __index = class.staticVariables } )\
            setmetatable( self.methods, { __index = class.methods } )\
            setmetatable( self.publicVariables, { __index = class.publicVariables } )\
        end\
    end\
    function cls:AddVariable( name, default, ... )\
        local types = { ... }\
        if #types == 0 then\
            types = false\
        end\
        if types then\
            for i = 1,#types do\
                types[types[i]] = true\
                types[i] = nil\
            end\
        end\
        self.publicVariables[name] = { value = default, types = types }\
    end\
    function cls:AddStaticVariable( name, default, ... )\
        local types = { ... }\
        if #types == 0 then\
            types = false\
        end\
        if types then\
            for i = 1,#types do\
                types[types[i]] = true\
                types[i] = nil\
            end\
        end\
        self.staticVariables[name] = { value = default, types = types }\
    end\
    function cls:AddPrivateVariable( name, default, ... )\
        local types = { ... }\
        if #types == 0 then\
            types = false\
        end\
        if types then\
            for i = 1,#types do\
                types[types[i]] = true\
                types[i] = nil\
            end\
        end\
        self.privateVariables[name] = { value = default, types = types }\
    end\
    function cls:AddPrivateMethod( name, method )\
        self.privateMethods[name] = method\
    end\
    function cls:AddMethod( name, method )\
        self.methods[name] = method\
    end\
    function cls:New( ... )\
        local args = { ... }\
        local ob = { }\
        local data = {\
            privateVariables = { };\
            privateMethods = { };\
            staticVariables = { };\
            methods = { };\
            publicVariables = { };\
        }\
        setmetatable( data.privateVariables, { __index = self.privateVariables } )\
        setmetatable( data.privateMethods, { __index = self.privateMethods } )\
        setmetatable( data.staticVariables, { __index = self.staticVariables } )\
        setmetatable( data.methods, { __index = self.methods } )\
        setmetatable( data.publicVariables, { __index = self.publicVariables } )\
        local meta = { }\
        local parents = { }\
        local c = self.parent\
        while c do\
            table.insert( parents, 1, c )\
            c = c.parent\
        end\
        \
        local variable\
        variable = function( mode, _type, name, ... )\
            local args = { ... }\
            local t = { }\
            if _type == \"private\" then\
                t = data.privateVariables\
            elseif _type == \"static\" then\
                t = data.staticVariables\
            elseif _type == \"public\" then\
                t = data.publicVariables\
            elseif _type == \"pmethod\" then\
                t = data.privateMethods\
            elseif _type == \"method\" then\
                t = data.methods\
            end\
            if t[name] then\
                if mode == \"set\" then\
                    if not t[name].types then\
                        t[name] = { value = args[1], types = false }\
                        return true\
                    end\
                    local _type_ = type( args[1] )\
                    if t[name].types[_type_] then\
                        t[name] = { value = args[1], types = t[name].types }\
                        return true\
                    end\
                    if _type_ == \"table\" and type( args[1].Type ) == \"function\" then\
                        local ftype = args[1]:Type( true )\
                        for i = 1,#ftype do\
                            if t[name].types[ftype:sub( 1, i )] then\
                                t[name] = { value = args[1], types = t[name].types }\
                                return true\
                            end\
                        end\
                    end\
                    return false, \"Invalid variable type (\".._type_..\")\"\
                elseif mode == \"get\" then\
                    return t[name].value\
                elseif mode == \"call\" and ( _type == \"method\" or _type == \"pmethod\" ) then\
                    return t[name]( ob, variable, unpack( args ) )\
                end\
            else\
                error( \"Could not access variable \\\"\"..tostring( name )..\"\\\"\", 2 )\
            end\
        end\
        \
        meta.__index = function( meta, key )\
            if data.methods[key] then\
                return function( object, ... )\
                    if object == ob then\
                        return variable( \"call\", \"method\", key, ... )\
                    end\
                    error( \"Use the : operator to call object methods.\", 2 )\
                end\
            elseif data.publicVariables[key] then\
                return variable( \"get\", \"public\", key )\
            elseif data.staticVariables[key] then\
                return variable( \"get\", \"static\", key )\
            end\
        end\
        meta.__newindex = function( meta, key, value )\
            if data.publicVariables[key] then\
                local ok, err = variable( \"set\", \"public\", key, value )\
                if ok ~= true then\
                    error( err, 2 )\
                end\
            else\
                error( \"Attempt to change protected variable or method\", 2 )\
            end\
        end\
        meta.__tostring = function( )\
            if self.Describe then\
                return self.Describe( ob, variable )\
            else\
                for i = #parents, 1, -1 do\
                    if parents[i].Describe then\
                        return parents[i].Describe( ob, variable )\
                    end\
                end\
                return \"Object of class \\\"\"..self.name..\"\\\"\"\
            end\
        end\
        \
        function ob.Class( )\
            return self\
        end\
        function ob:Type( full )\
            local cls = self:Class( )\
            if not full then\
                return cls.name\
            end\
            local parents = { }\
            while cls do\
                table.insert( parents, 1, cls )\
                cls = cls.parent\
            end\
            local str = \"\"\
            for i = 1,#parents-1 do\
                str = str..parents[i].name..\".\"\
            end\
            return str..self:Class( ).name\
        end\
        function ob:TypeOf( _type )\
            local cls = self:Class( )\
            while cls do\
                if cls.name == _type then\
                    return true\
                end\
                cls = cls.parent\
            end\
            return false\
        end\
        function ob:GetExpectedVariableTypes( name )\
            if data.publicVariables[name] then\
                if not data.publicVariables[name].types then\
                    return true, \"No expected types\"\
                end\
                local t = { }\
                for k, v in pairs( data.publicVariables[name].types ) do\
                    table.insert( t, k )\
                end\
                return true, t\
            else\
                return false, \"No such variable\"\
            end\
        end\
        \
        setmetatable( ob, meta )\
        \
        for i = 1,#parents do\
            if parents[i].Init then\
                local ok, data = pcall( parents[i].Init, ob, variable, args )\
                if not ok then\
                    error( data, 2 )\
                elseif data == false then\
                    return false\
                end\
            end\
        end\
        if self.Init then\
            local ok, data = pcall( self.Init, ob, variable, args )\
            if not ok then\
                error( data, 2 )\
            elseif data == false then\
                return false\
            end\
        end\
\
        return ob\
    end\
    setmetatable( cls, { __tostring = function( self ) return \"Class \"..self.name end, __call = cls.New } )\
    classes[name] = cls\
    return cls\
end\
Class.Type = function( value )\
    local _type = type( value )\
    if _type == \"table\" then\
        if type( value.Type ) == \"function\" then\
            return value:Type( )\
        end\
    end\
    return _type\
end\
Class.TypeOf = function( value, _type_ )\
    if type( value ) == \"table\" and type( value.TypeOf ) == \"function\" then\
        return value:TypeOf( _type_ )\
    end\
    return false\
end\
Class.CheckType = function( object, ... )\
    local values = { ... }\
    local _type = type( object )\
    for i = 1,#values do\
        if _type == values[i] then\
            return true, values[i]\
        end\
    end\
    if _type == \"table\" and type( object.Type ) == \"function\" then\
        local _type = object:Type( true )\
        for i = 1,#values do\
            if _type == values[i] then\
                return true, values[i]\
            end\
        end\
    end\
    return false\
end\
Class.CheckTypeOf = function( object, ... )\
    local values = { ... }\
    local _type = type( object )\
    for i = 1,#values do\
        if _type == values[i] then\
            return true, values[i]\
        end\
    end\
    if _type == \"table\" and type( object.TypeOf ) == \"function\" then\
        for i = 1,#values do\
            if object:TypeOf( values[i] ) then\
                return true, values[i]\
            end\
        end\
    end\
    return false\
end\
\
Class.Load = function( name, classPath, _env )\
    local check = {\
        \".class\";\
        \".lua\";\
        \"\";\
    }\
    for i = 1,#check do\
        if fs.exists( classPath..\"/\"..name..check[i] ) then\
            local h = fs.open( classPath..\"/\"..name..check[i], \"r\" )\
            local f, err = loadstring( h.readAll( ), \"Class \"..name )\
            h.close( )\
            if not f then\
                error( err, 0 )\
            end\
            local env = { }\
            setmetatable( env, { __index = _env } )\
            env[name] = Class.New( name )\
            env.Class = Class\
            setfenv( f, env )\
            local ok, err = pcall( f )\
            if not ok then\
                error( err, 0 )\
            end\
            return env[name], name..check[i]\
        end\
    end\
end\
\
setmetatable( Class, { __call = function( self, ... ) return Class.New( ... ) end } )\
\
local New = { }\
setmetatable( New, {\
    __index = function( _, key )\
        if classes[key] then\
            return function( ... )\
                return classes[key]:New( ... )\
            end\
        else\
            error( \"Class not found (\"..key..\")\", 2 )\
        end\
    end;\
    __newindex = function( ) end;\
} )\
\
getfenv( ).New = New\
getfenv( ).Class = Class",
    ["Utils.lua"] = "\
local fs = ...\
local _version\
if fs.exists( \"Nova/.version\" ) then\
    local h = fs.open( \"Nova/.version\", \"r\" )\
    _version = h.readAll( )\
    h.close( )\
else\
    _version = \"1.24\"\
end\
\
local utils = { }\
utils.loadClasses = function( path, class, env )\
    local cenv = { }\
    setmetatable( cenv, { __index = getfenv( ) } )\
    if not env then\
        env = { }\
        setmetatable( env, { __index = getfenv( ) } )\
    end\
    local f, err = loadfile( path )\
    if not f then\
        error( err, 2 )\
    end\
    setfenv( f, cenv )\
    local ok, err = pcall( f )\
    if not ok then \
        error( err, 2 )\
    end\
    for k, v in pairs( cenv ) do\
        env[k] = v\
    end\
    local donefiles = { }\
    local classes = { }\
    local h = fs.open( class..\"/list.txt\", \"r\" )\
    if h then\
        local files = { }\
        local line = h.readLine( )\
        while line do\
            table.insert( files, line )\
            line = h.readLine( )\
        end\
        h.close( )\
        local p\
        for i = 1,#files do\
            classes[files[i]], p = cenv.Class.Load( files[i], class, env )\
            if p then\
                donefiles[p] = true\
            end\
        end\
    end\
    local files = fs.list( class )\
    for i = 1,#files do\
        local name, count = files[i]:gsub( \".class$\", \"\" )\
        if count > 0 and files[i] ~= \"list.txt\" and not donefiles[files[i]] then\
            classes[name], p = env.Class.Load( name, class, env )\
            if p then\
                donefiles[p] = true\
            end\
        end\
    end\
    return env.New, env.Class, classes\
end\
utils.loadConfig = function( path )\
    local h = fs.open( path, \"r\" )\
    if h then\
        local lines = { }\
        local line = h.readLine( )\
        while line do\
            table.insert( lines, line )\
            line = h.readLine( )\
        end\
        h.close( )\
        local config = { }\
        for i = 1,#lines do\
            local eq = lines[i]:find( \"::\" )\
            if eq then\
                local name = lines[i]:sub( 1, eq - 1 )\
                local data = lines[i]:sub( eq + 2 )\
                if tonumber( data ) then\
                    config[name] = tonumber( data )\
                elseif data == \"true\" or data == \"false\" then\
                    config[name] = data == \"true\"\
                else\
                    config[name] = data\
                end\
            end\
        end\
        return config\
    end\
    return { }\
end\
utils.loadResources = function( path, env )\
    env.Resources = { }\
    local load\
    load = function( path )\
        if fs.isDir( path ) then\
            local data = { }\
            local files = fs.list( path )\
            for i = 1,#files do\
                local name = files[i]:gsub( \".%w+$\", \"\" )\
                data[name] = load( path..\"/\"..files[i] )\
            end\
            return data\
        else\
            local f, err = loadfile( path )\
            if f then\
                local e = { }\
                setmetatable( e, { __index = env } )\
                setfenv( f, e )\
                local ok, data = pcall( f )\
                if not ok then\
                    error( data, 2 )\
                end\
                local t = { }\
                for k, v in pairs( e ) do\
                    t[k] = v\
                end\
                return t\
            else\
                error( err, 2 )\
            end\
        end\
    end\
    local t = load( path )\
    for k, v in pairs( t ) do\
        env.Resources[k] = v\
    end\
    return env.Resources\
end\
utils.formatEnvironment = function( path, classes, class )\
    local filesystem = classes.FilesystemRedirect:New( path )\
\
    local env = { }\
    env.Classes = classes\
    env.Class = class\
\
    env.New = { }\
    setmetatable( env.New, {\
        __index = function( _, key )\
            if classes[key] then\
                return function( ... )\
                    return classes[key]:New( ... )\
                end\
            else\
                error( \"Class not found (\"..key..\")\", 2 )\
            end\
        end;\
        __newindex = function( ) end;\
    } )\
\
    env.Nova = { }\
    env.Nova.name = \"Nova Utilities\"\
    env.Nova.version = _version\
    env.Nova.author = \"awsumben13\"\
    env.Nova.installed = fs.isDir( \"Nova\" )\
    env.Nova.programPath = path\
    if env.Nova.installed then\
        env.Nova.fs = classes.FilesystemRedirect:New( \"Nova\" )\
    end\
    \
    env.coroutine = coroutine\
    env.math = math\
    env.string = string\
    env.table = table\
    env.tostring = tostring\
    env.tonumber = tonumber\
    env.pairs = pairs\
    env.ipairs = ipairs\
    env.next = next\
    env.select = select\
    env.setfenv = setfenv\
    env.getfenv = getfenv\
    env.assert = assert\
    env.pcall = pcall\
    env.xpcall = xpcall\
    env.error = error\
    env.type = type\
    env.unpack = unpack\
    env.setmetatable = setmetatable\
    env.getmetatable = getmetatable\
    env.rawset = rawset\
    env.rawget = rawget\
    env.rawequal = rawequal\
    env.print = print\
    env._VERSION = _VERSION\
    \
    env.write = write\
    env.read = read\
    \
    env.rootfs = fs\
    env.fs = filesystem:Redirect( )\
    env.io = io\
    env.loadstring = function( str, name )\
        local ok, f, err = pcall( loadstring, str, name )\
        if not ok then\
            error( f, 2 )\
        elseif not f then\
            error( err, 2 )\
        end\
        setfenv( f, env )\
        return f\
    end\
    env.loadfile = function( _sFile )\
        local file = env.fs.open( _sFile, \"r\" )\
        if file then\
            local func, err = env.loadstring( file.readAll( ), tostring( env.fs.getName( _sFile ) ) )\
            file.close( )\
            return func, err\
        end\
        return nil, \"File not found\"\
    end\
    env.dofile = function( _sFile )\
        local fnFile, e = env.loadfile( _sFile )\
        if fnFile then\
            return fnFile( )\
        else\
            error( e, 2 )\
        end\
    end\
    \
    env.os = { }\
    setmetatable( env.os, { __index = os } )\
    local tAPIsLoading = {}\
    function env.os.loadAPI( _sPath )\
        local sName = fs.getName( _sPath )\
        if tAPIsLoading[sName] == true then\
            printError( \"API \"..sName..\" is already being loaded\" )\
            return false\
        end\
        tAPIsLoading[sName] = true\
            \
        local tEnv = {}\
        setmetatable( tEnv, { __index = env } )\
        local fnAPI, err = env.loadfile( _sPath )\
        if fnAPI then\
            setfenv( fnAPI, tEnv )\
            fnAPI()\
        else\
            printError( err )\
            tAPIsLoading[sName] = nil\
            return false\
        end\
        \
        local tAPI = {}\
        for k,v in pairs( tEnv ) do\
            tAPI[k] =  v\
        end\
        \
        env[sName] = tAPI\
        tAPIsLoading[sName] = nil\
        return true\
    end\
    function env.os.unloadAPI( _sName )\
        if _sName ~= \"_G\" and type(env[_sName]) == \"table\" then\
            env[_sName] = nil\
        end\
    end\
    function env.os.run( _tEnv, _sPath, ... ) -- copied from bios.lua\
        local tArgs = { ... }\
        local fnFile, err = loadfile( _sPath )\
        if fnFile then\
            local tEnv = _tEnv\
            setmetatable( tEnv, { __index = env } )\
            setfenv( fnFile, tEnv )\
            local ok, err = pcall( function()\
                fnFile( unpack( tArgs ) )\
            end )\
            if not ok then\
                if err and err ~= \"\" then\
                    printError( err )\
                end\
                return false\
            end\
            return true\
        end\
        if err and err ~= \"\" then\
            printError( err )\
        end\
        return false\
    end\
    \
    env.term = term\
    env.textutils = textutils\
    env.keys = keys\
    env.printError = printError\
    env.colours = colours\
    env.colors = colors\
    env.sleep = sleep\
    env.redstone = redstone\
    env.peripheral = peripheral\
    env.rs = rs\
    env.rednet = rednet\
    env.http = http\
    env.vector = vector\
    env.parallel = parallel\
    env.window = window\
    env.help = help\
    env.gps = gps\
    env.bit = bit\
    env.disk = disk\
    env.paintutils = paintutils\
    env.__inext = __inext\
    \
    local programStack = { }\
    env.shell = { }\
    for k, v in pairs( shell ) do\
        env.shell[k] = v\
    end\
    env.shell.run = function( program, ... ) -- copied from shell and removed the multishell stuff (an fs.redirect function really needs to be added to cc)\
        if type( program ) == \"string\" then\
            local path = filesystem:GetPath( program )\
            local p =  fs.combine( path, program )\
            local sPath = shell.resolveProgram( p )\
            if sPath ~= nil then\
                programStack[#programStack + 1] = sPath\
                local result = env.os.run( env, sPath, ... )\
                programStack[#programStack] = nil\
                return result\
            else\
                printError( \"No such program\" )\
                return false\
            end\
        else\
            error( \"String expected, got \"..type( program ), 2 )\
        end\
    end\
    env.shell.getRunningProgram = function( )\
        return programStack[#programStack]\
    end\
    env.shell.exit = function( )\
        error( \"Exited\", 0 )\
    end\
    env._G = env\
    \
    local f, err = loadfile( \"rom/apis/io\" )\
    if f then\
        local e = { }\
        setmetatable( e, { __index = env } )\
        setfenv( f, e )\
        local ok, err = pcall( f )\
        if not ok then\
            error( err )\
        end\
        env.io = { }\
        for k, v in pairs( e ) do\
            env.io[k] = v\
        end\
    else\
        error( err, 0 )\
    end\
    \
    return env, filesystem\
end\
\
utils.isValidPath = function( path )\
    local ok = type( path ) == \"string\"\
    ok = ok and fs.isDir( path )\
    ok = ok and fs.exists( path..\"/main.lua\" )\
    ok = ok and fs.exists( path..\"/main.conf\" )\
    return ok\
end\
\
utils.checkForUpdates = function( )\
    if http then\
        local response = http.get( \"http://pastebin.com/raw.php?i=ijWMGfJ6\" )\
        if response then\
            local version = tonumber( response.readAll( ) )\
            response.close( )\
            if tonumber( _version ) < version then\
                return true, tostring( version )\
            end\
            return false, \"No update required.\"\
        else\
            return false, \"Could not connect to pastebin.\"\
        end\
    else\
        return false, \"Http not found.\"\
    end\
end\
utils.update = function( )\
    if http then\
        local response = http.get( \"http://pastebin.com/raw.php?i=dUcPAapV\" )\
        if response then\
            local update = response.readAll( )\
            response.close( )\
            local tempPath = \"NovaPacked\"\
            fs.delete( tempPath )\
            local h = fs.open( tempPath, \"w\" )\
            if h then\
                h.write( update )\
                h.close( )\
                local f, err = loadfile( tempPath )\
                if not f then\
                    error( err, 0 )\
                end\
                f( )\
            else\
                return false, \"Could not open file.\"\
            end\
        else\
            return false, \"Could not connect to pastebin.\"\
        end\
    else\
        return false, \"Http not found.\"\
    end\
end\
\
utils.run = function( path, env, config, filesystem, args )\
    local f, err = loadfile( path..\"/main.lua\" )\
    if not f then\
        error( err, 0 )\
    end\
    setfenv( f, env )\
    local co = coroutine.create( f )\
    local ok, err = coroutine.resume( co, unpack( args ) )\
    if not ok then\
        error( err, 0 )\
    end\
    while coroutine.status( co ) ~= \"dead\" do\
        local ok, err = coroutine.resume( co, coroutine.yield( ) )\
        if not ok then\
            error( err, 0 )\
        end\
        if coroutine.status( co ) == \"dead\" and config[\"Keep Running\"] then\
            co = coroutine.create( f )\
        end\
    end\
end\
\
return utils",
}
--PackageEnd
local saveDir
saveDir = function( path, t )
    if not fs.isDir( path ) then
        fs.makeDir( path )
    end
    for k, v in pairs( t ) do
        if type( v ) == "table" then
            saveDir( path.."/"..k, v )
        else
            local f = fs.open( path.."/"..k, "w" )
            if f then
                f.write( v )
                f.close( )
            end
        end
    end
end
fs.delete( outfile )
saveDir( outfile, files )
if outfile ~= infile then
    fs.delete( infile )
end
if fs.exists( outfile.."/install.lua" ) then
    shell.run( outfile.."/install.lua" )
end