isaacscript-common 1.2.97 → 1.2.98

package/dist/lualib_bundle.lua

@@ -1,8 +1,8 @@
-local function __TS__ArrayIsArray(value)
+function __TS__ArrayIsArray(value)
     return type(value) == "table" and (value[1] ~= nil or next(value, nil) == nil)
 end
 
-local function __TS__ArrayConcat(arr1, ...)
+function __TS__ArrayConcat(arr1, ...)
     local args = {...}
     local out = {}
     for ____, val in ipairs(arr1) do
@@ -21,23 +21,7 @@ local function __TS__ArrayConcat(arr1, ...)
     return out
 end
 
-local __TS__Symbol, Symbol
-do
-    local symbolMetatable = {__tostring = function(self)
-        return ("Symbol(" .. (self.description or "")) .. ")"
-    end}
-    function __TS__Symbol(description)
-        return setmetatable({description = description}, symbolMetatable)
-    end
-    Symbol = {
-        iterator = __TS__Symbol("Symbol.iterator"),
-        hasInstance = __TS__Symbol("Symbol.hasInstance"),
-        species = __TS__Symbol("Symbol.species"),
-        toStringTag = __TS__Symbol("Symbol.toStringTag")
-    }
-end
-
-local function __TS__ArrayEntries(array)
+function __TS__ArrayEntries(array)
     local key = 0
     return {
         [Symbol.iterator] = function(self)
@@ -51,11 +35,11 @@ local function __TS__ArrayEntries(array)
     }
 end
 
-local function __TS__ArrayEvery(arr, callbackfn)
+function __TS__ArrayEvery(arr, callbackfn)
     do
         local i = 0
         while i < #arr do
-            if not callbackfn(nil, arr[i + 1], i, arr) then
+            if not callbackfn(_G, arr[i + 1], i, arr) then
                 return false
             end
             i = i + 1
@@ -64,12 +48,12 @@ local function __TS__ArrayEvery(arr, callbackfn)
     return true
 end
 
-local function __TS__ArrayFilter(arr, callbackfn)
+function __TS__ArrayFilter(arr, callbackfn)
     local result = {}
     do
         local i = 0
         while i < #arr do
-            if callbackfn(nil, arr[i + 1], i, arr) then
+            if callbackfn(_G, arr[i + 1], i, arr) then
                 result[#result + 1] = arr[i + 1]
             end
             i = i + 1
@@ -78,12 +62,22 @@ local function __TS__ArrayFilter(arr, callbackfn)
     return result
 end
 
-local function __TS__ArrayFind(arr, predicate)
+function __TS__ArrayForEach(arr, callbackFn)
+    do
+        local i = 0
+        while i < #arr do
+            callbackFn(_G, arr[i + 1], i, arr)
+            i = i + 1
+        end
+    end
+end
+
+function __TS__ArrayFind(arr, predicate)
     local len = #arr
     local k = 0
     while k < len do
         local elem = arr[k + 1]
-        if predicate(nil, elem, k, arr) then
+        if predicate(_G, elem, k, arr) then
             return elem
         end
         k = k + 1
@@ -91,12 +85,12 @@ local function __TS__ArrayFind(arr, predicate)
     return nil
 end
 
-local function __TS__ArrayFindIndex(arr, callbackFn)
+function __TS__ArrayFindIndex(arr, callbackFn)
     do
         local i = 0
         local len = #arr
         while i < len do
-            if callbackFn(nil, arr[i + 1], i, arr) then
+            if callbackFn(_G, arr[i + 1], i, arr) then
                 return i
             end
             i = i + 1
@@ -105,52 +99,7 @@ local function __TS__ArrayFindIndex(arr, callbackFn)
     return -1
 end
 
-local function __TS__ArrayFlat(array, depth)
-    if depth == nil then
-        depth = 1
-    end
-    local result = {}
-    for ____, value in ipairs(array) do
-        if depth > 0 and __TS__ArrayIsArray(value) then
-            result = __TS__ArrayConcat(
-                result,
-                __TS__ArrayFlat(value, depth - 1)
-            )
-        else
-            result[#result + 1] = value
-        end
-    end
-    return result
-end
-
-local function __TS__ArrayFlatMap(array, callback)
-    local result = {}
-    do
-        local i = 0
-        while i < #array do
-            local value = callback(nil, array[i + 1], i, array)
-            if type(value) == "table" and __TS__ArrayIsArray(value) then
-                result = __TS__ArrayConcat(result, value)
-            else
-                result[#result + 1] = value
-            end
-            i = i + 1
-        end
-    end
-    return result
-end
-
-local function __TS__ArrayForEach(arr, callbackFn)
-    do
-        local i = 0
-        while i < #arr do
-            callbackFn(nil, arr[i + 1], i, arr)
-            i = i + 1
-        end
-    end
-end
-
-local function __TS__ArrayIncludes(self, searchElement, fromIndex)
+function __TS__ArrayIncludes(self, searchElement, fromIndex)
     if fromIndex == nil then
         fromIndex = 0
     end
@@ -170,7 +119,7 @@ local function __TS__ArrayIncludes(self, searchElement, fromIndex)
     return false
 end
 
-local function __TS__ArrayIndexOf(arr, searchElement, fromIndex)
+function __TS__ArrayIndexOf(arr, searchElement, fromIndex)
     local len = #arr
     if len == 0 then
         return -1
@@ -203,7 +152,7 @@ local function __TS__ArrayIndexOf(arr, searchElement, fromIndex)
     return -1
 end
 
-local function __TS__ArrayJoin(self, separator)
+function __TS__ArrayJoin(self, separator)
     if separator == nil then
         separator = ","
     end
@@ -217,19 +166,19 @@ local function __TS__ArrayJoin(self, separator)
     return result
 end
 
-local function __TS__ArrayMap(arr, callbackfn)
+function __TS__ArrayMap(arr, callbackfn)
     local newArray = {}
     do
         local i = 0
         while i < #arr do
-            newArray[i + 1] = callbackfn(nil, arr[i + 1], i, arr)
+            newArray[i + 1] = callbackfn(_G, arr[i + 1], i, arr)
             i = i + 1
         end
     end
     return newArray
 end
 
-local function __TS__ArrayPush(arr, ...)
+function __TS__ArrayPush(arr, ...)
     local items = {...}
     for ____, item in ipairs(items) do
         arr[#arr + 1] = item
@@ -237,7 +186,7 @@ local function __TS__ArrayPush(arr, ...)
     return #arr
 end
 
-local function __TS__ArrayReduce(arr, callbackFn, ...)
+function __TS__ArrayReduce(arr, callbackFn, ...)
     local len = #arr
     local k = 0
     local accumulator = nil
@@ -251,7 +200,7 @@ local function __TS__ArrayReduce(arr, callbackFn, ...)
     end
     for i = k, len - 1 do
         accumulator = callbackFn(
-            nil,
+            _G,
             accumulator,
             arr[i + 1],
             i,
@@ -261,7 +210,7 @@ local function __TS__ArrayReduce(arr, callbackFn, ...)
     return accumulator
 end
 
-local function __TS__ArrayReduceRight(arr, callbackFn, ...)
+function __TS__ArrayReduceRight(arr, callbackFn, ...)
     local len = #arr
     local k = len - 1
     local accumulator = nil
@@ -275,7 +224,7 @@ local function __TS__ArrayReduceRight(arr, callbackFn, ...)
     end
     for i = k, 0, -1 do
         accumulator = callbackFn(
-            nil,
+            _G,
             accumulator,
             arr[i + 1],
             i,
@@ -285,7 +234,7 @@ local function __TS__ArrayReduceRight(arr, callbackFn, ...)
     return accumulator
 end
 
-local function __TS__ArrayReverse(arr)
+function __TS__ArrayReverse(arr)
     local i = 0
     local j = #arr - 1
     while i < j do
@@ -298,28 +247,35 @@ local function __TS__ArrayReverse(arr)
     return arr
 end
 
-local function __TS__ArraySetLength(arr, length)
-    if length < 0 or length ~= length or length == math.huge or math.floor(length) ~= length then
-        error(
-            "invalid array length: " .. tostring(length),
-            0
-        )
-    end
+function __TS__ArrayShift(arr)
+    return table.remove(arr, 1)
+end
+
+function __TS__ArrayUnshift(arr, ...)
+    local items = {...}
     do
-        local i = #arr - 1
-        while i >= length do
-            arr[i + 1] = nil
+        local i = #items - 1
+        while i >= 0 do
+            table.insert(arr, 1, items[i + 1])
             i = i - 1
         end
     end
-    return length
+    return #arr
 end
 
-local function __TS__ArrayShift(arr)
-    return table.remove(arr, 1)
+function __TS__ArraySort(arr, compareFn)
+    if compareFn ~= nil then
+        table.sort(
+            arr,
+            function(a, b) return compareFn(_G, a, b) < 0 end
+        )
+    else
+        table.sort(arr)
+    end
+    return arr
 end
 
-local function __TS__ArraySlice(list, first, last)
+function __TS__ArraySlice(list, first, last)
     local len = #list
     local relativeStart = first or 0
     local k
@@ -348,11 +304,11 @@ local function __TS__ArraySlice(list, first, last)
     return out
 end
 
-local function __TS__ArraySome(arr, callbackfn)
+function __TS__ArraySome(arr, callbackfn)
     do
         local i = 0
         while i < #arr do
-            if callbackfn(nil, arr[i + 1], i, arr) then
+            if callbackfn(_G, arr[i + 1], i, arr) then
                 return true
             end
             i = i + 1
@@ -361,19 +317,7 @@ local function __TS__ArraySome(arr, callbackfn)
     return false
 end
 
-local function __TS__ArraySort(arr, compareFn)
-    if compareFn ~= nil then
-        table.sort(
-            arr,
-            function(a, b) return compareFn(nil, a, b) < 0 end
-        )
-    else
-        table.sort(arr)
-    end
-    return arr
-end
-
-local function __TS__ArraySplice(list, ...)
+function __TS__ArraySplice(list, ...)
     local len = #list
     local actualArgumentCount = select("#", ...)
     local start = select(1, ...)
@@ -458,7 +402,7 @@ local function __TS__ArraySplice(list, ...)
     return out
 end
 
-local function __TS__ArrayToObject(array)
+function __TS__ArrayToObject(array)
     local object = {}
     do
         local i = 0
@@ -470,25 +414,72 @@ local function __TS__ArrayToObject(array)
     return object
 end
 
-local function __TS__ArrayUnshift(arr, ...)
-    local items = {...}
+function __TS__ArrayFlat(array, depth)
+    if depth == nil then
+        depth = 1
+    end
+    local result = {}
+    for ____, value in ipairs(array) do
+        if depth > 0 and __TS__ArrayIsArray(value) then
+            result = __TS__ArrayConcat(
+                result,
+                __TS__ArrayFlat(value, depth - 1)
+            )
+        else
+            result[#result + 1] = value
+        end
+    end
+    return result
+end
+
+function __TS__ArrayFlatMap(array, callback)
+    local result = {}
     do
-        local i = #items - 1
-        while i >= 0 do
-            table.insert(arr, 1, items[i + 1])
+        local i = 0
+        while i < #array do
+            local value = callback(_G, array[i + 1], i, array)
+            if type(value) == "table" and __TS__ArrayIsArray(value) then
+                result = __TS__ArrayConcat(result, value)
+            else
+                result[#result + 1] = value
+            end
+            i = i + 1
+        end
+    end
+    return result
+end
+
+function __TS__ArraySetLength(arr, length)
+    if length < 0 or length ~= length or length == math.huge or math.floor(length) ~= length then
+        error(
+            "invalid array length: " .. tostring(length),
+            0
+        )
+    end
+    do
+        local i = #arr - 1
+        while i >= length do
+            arr[i + 1] = nil
             i = i - 1
         end
     end
-    return #arr
+    return length
 end
 
-local function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(...)
-    return instance
+____symbolMetatable = {__tostring = function(self)
+    return ("Symbol(" .. (self.description or "")) .. ")"
+end}
+function __TS__Symbol(description)
+    return setmetatable({description = description}, ____symbolMetatable)
 end
+Symbol = {
+    iterator = __TS__Symbol("Symbol.iterator"),
+    hasInstance = __TS__Symbol("Symbol.hasInstance"),
+    species = __TS__Symbol("Symbol.species"),
+    toStringTag = __TS__Symbol("Symbol.toStringTag")
+}
 
-local function __TS__InstanceOf(obj, classTbl)
+function __TS__InstanceOf(obj, classTbl)
     if type(classTbl) ~= "table" then
         error("Right-hand side of 'instanceof' is not an object", 0)
     end
@@ -507,16 +498,22 @@ local function __TS__InstanceOf(obj, classTbl)
     return false
 end
 
-local function __TS__Class(self)
+function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
+function __TS__Class(self)
     local c = {prototype = {}}
     c.prototype.__index = c.prototype
     c.prototype.constructor = c
     return c
 end
 
-local __TS__Unpack = table.unpack or unpack
+__TS__Unpack = table.unpack or unpack
 
-local function __TS__FunctionBind(fn, thisArg, ...)
+function __TS__FunctionBind(fn, thisArg, ...)
     local boundArgs = {...}
     return function(____, ...)
         local args = {...}
@@ -534,180 +531,184 @@ local function __TS__FunctionBind(fn, thisArg, ...)
     end
 end
 
-local __TS__Promise
-do
-    local function promiseDeferred(self)
-        local resolve
-        local reject
-        local promise = __TS__New(
-            __TS__Promise,
-            function(____, res, rej)
-                resolve = res
-                reject = rej
-            end
-        )
-        return {promise = promise, resolve = resolve, reject = reject}
-    end
-    local function isPromiseLike(self, thing)
-        return __TS__InstanceOf(thing, __TS__Promise)
-    end
-    __TS__Promise = __TS__Class()
-    __TS__Promise.name = "__TS__Promise"
-    function __TS__Promise.prototype.____constructor(self, executor)
-        self.state = 0
-        self.fulfilledCallbacks = {}
-        self.rejectedCallbacks = {}
-        self.finallyCallbacks = {}
-        do
-            local function ____catch(e)
-                self:reject(e)
-            end
-            local ____try, ____hasReturned = pcall(function()
-                executor(
-                    nil,
-                    __TS__FunctionBind(self.resolve, self),
-                    __TS__FunctionBind(self.reject, self)
-                )
-            end)
-            if not ____try then
-                ____catch(____hasReturned)
-            end
+__TS__PromiseState = __TS__PromiseState or ({})
+__TS__PromiseState.Pending = 0
+__TS__PromiseState[__TS__PromiseState.Pending] = "Pending"
+__TS__PromiseState.Fulfilled = 1
+__TS__PromiseState[__TS__PromiseState.Fulfilled] = "Fulfilled"
+__TS__PromiseState.Rejected = 2
+__TS__PromiseState[__TS__PromiseState.Rejected] = "Rejected"
+function __TS__PromiseDeferred(self)
+    local resolve
+    local reject
+    local promise = __TS__New(
+        __TS__Promise,
+        function(____, res, rej)
+            resolve = res
+            reject = rej
         end
-    end
-    function __TS__Promise.resolve(data)
-        local promise = __TS__New(
-            __TS__Promise,
-            function()
-            end
-        )
-        promise.state = 1
-        promise.value = data
-        return promise
-    end
-    function __TS__Promise.reject(reason)
-        local promise = __TS__New(
-            __TS__Promise,
-            function()
-            end
-        )
-        promise.state = 2
-        promise.rejectionReason = reason
-        return promise
-    end
-    __TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
-        local ____promiseDeferred_result_0 = promiseDeferred(nil)
-        local promise = ____promiseDeferred_result_0.promise
-        local resolve = ____promiseDeferred_result_0.resolve
-        local reject = ____promiseDeferred_result_0.reject
-        local isFulfilled = self.state == 1
-        local isRejected = self.state == 2
-        if onFulfilled then
-            local internalCallback = self:createPromiseResolvingCallback(onFulfilled, resolve, reject)
-            __TS__ArrayPush(self.fulfilledCallbacks, internalCallback)
-            if isFulfilled then
-                internalCallback(nil, self.value)
-            end
-        else
-            __TS__ArrayPush(
-                self.fulfilledCallbacks,
-                function() return resolve(nil, nil) end
+    )
+    return {promise = promise, resolve = resolve, reject = reject}
+end
+function __TS__IsPromiseLike(self, thing)
+    return __TS__InstanceOf(thing, __TS__Promise)
+end
+__TS__Promise = __TS__Class()
+__TS__Promise.name = "__TS__Promise"
+function __TS__Promise.prototype.____constructor(self, executor)
+    self.state = __TS__PromiseState.Pending
+    self.fulfilledCallbacks = {}
+    self.rejectedCallbacks = {}
+    self.finallyCallbacks = {}
+    do
+        local function ____catch(e)
+            self:reject(e)
+        end
+        local ____try, ____hasReturned = pcall(function()
+            executor(
+                _G,
+                __TS__FunctionBind(self.resolve, self),
+                __TS__FunctionBind(self.reject, self)
             )
+        end)
+        if not ____try then
+            ____catch(____hasReturned)
         end
-        if onRejected then
-            local internalCallback = self:createPromiseResolvingCallback(onRejected, resolve, reject)
-            __TS__ArrayPush(self.rejectedCallbacks, internalCallback)
-            if isRejected then
-                internalCallback(nil, self.rejectionReason)
-            end
+    end
+end
+function __TS__Promise.resolve(data)
+    local promise = __TS__New(
+        __TS__Promise,
+        function()
+        end
+    )
+    promise.state = __TS__PromiseState.Fulfilled
+    promise.value = data
+    return promise
+end
+function __TS__Promise.reject(reason)
+    local promise = __TS__New(
+        __TS__Promise,
+        function()
         end
+    )
+    promise.state = __TS__PromiseState.Rejected
+    promise.rejectionReason = reason
+    return promise
+end
+__TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
+    local ____TS__PromiseDeferred_result_0 = __TS__PromiseDeferred(_G)
+    local promise = ____TS__PromiseDeferred_result_0.promise
+    local resolve = ____TS__PromiseDeferred_result_0.resolve
+    local reject = ____TS__PromiseDeferred_result_0.reject
+    local isFulfilled = self.state == __TS__PromiseState.Fulfilled
+    local isRejected = self.state == __TS__PromiseState.Rejected
+    if onFulfilled then
+        local internalCallback = self:createPromiseResolvingCallback(onFulfilled, resolve, reject)
+        __TS__ArrayPush(self.fulfilledCallbacks, internalCallback)
         if isFulfilled then
-            resolve(nil, self.value)
+            internalCallback(_G, self.value)
         end
+    else
+        __TS__ArrayPush(
+            self.fulfilledCallbacks,
+            function() return resolve(_G, nil) end
+        )
+    end
+    if onRejected then
+        local internalCallback = self:createPromiseResolvingCallback(onRejected, resolve, reject)
+        __TS__ArrayPush(self.rejectedCallbacks, internalCallback)
         if isRejected then
-            reject(nil, self.rejectionReason)
+            internalCallback(_G, self.rejectionReason)
         end
-        return promise
     end
-    function __TS__Promise.prototype.catch(self, onRejected)
-        return self["then"](self, nil, onRejected)
+    if isFulfilled then
+        resolve(_G, self.value)
     end
-    function __TS__Promise.prototype.finally(self, onFinally)
-        if onFinally then
-            __TS__ArrayPush(self.finallyCallbacks, onFinally)
-            if self.state ~= 0 then
-                onFinally(nil)
-            end
+    if isRejected then
+        reject(_G, self.rejectionReason)
+    end
+    return promise
+end
+function __TS__Promise.prototype.catch(self, onRejected)
+    return self["then"](self, nil, onRejected)
+end
+function __TS__Promise.prototype.finally(self, onFinally)
+    if onFinally then
+        __TS__ArrayPush(self.finallyCallbacks, onFinally)
+        if self.state ~= __TS__PromiseState.Pending then
+            onFinally(_G)
         end
-        return self
     end
-    function __TS__Promise.prototype.resolve(self, data)
-        if __TS__InstanceOf(data, __TS__Promise) then
-            data["then"](
-                data,
-                function(____, v) return self:resolve(v) end,
-                function(____, err) return self:reject(err) end
-            )
-            return
+    return self
+end
+function __TS__Promise.prototype.resolve(self, data)
+    if __TS__InstanceOf(data, __TS__Promise) then
+        data["then"](
+            data,
+            function(____, v) return self:resolve(v) end,
+            function(____, err) return self:reject(err) end
+        )
+        return
+    end
+    if self.state == __TS__PromiseState.Pending then
+        self.state = __TS__PromiseState.Fulfilled
+        self.value = data
+        for ____, callback in ipairs(self.fulfilledCallbacks) do
+            callback(_G, data)
         end
-        if self.state == 0 then
-            self.state = 1
-            self.value = data
-            for ____, callback in ipairs(self.fulfilledCallbacks) do
-                callback(nil, data)
-            end
-            for ____, callback in ipairs(self.finallyCallbacks) do
-                callback(nil)
-            end
+        for ____, callback in ipairs(self.finallyCallbacks) do
+            callback(_G)
         end
     end
-    function __TS__Promise.prototype.reject(self, reason)
-        if self.state == 0 then
-            self.state = 2
-            self.rejectionReason = reason
-            for ____, callback in ipairs(self.rejectedCallbacks) do
-                callback(nil, reason)
-            end
-            for ____, callback in ipairs(self.finallyCallbacks) do
-                callback(nil)
-            end
+end
+function __TS__Promise.prototype.reject(self, reason)
+    if self.state == __TS__PromiseState.Pending then
+        self.state = __TS__PromiseState.Rejected
+        self.rejectionReason = reason
+        for ____, callback in ipairs(self.rejectedCallbacks) do
+            callback(_G, reason)
+        end
+        for ____, callback in ipairs(self.finallyCallbacks) do
+            callback(_G)
         end
     end
-    function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
-        return function(____, value)
-            do
-                local function ____catch(e)
-                    reject(nil, e)
-                end
-                local ____try, ____hasReturned = pcall(function()
-                    self:handleCallbackData(
-                        f(nil, value),
-                        resolve,
-                        reject
-                    )
-                end)
-                if not ____try then
-                    ____catch(____hasReturned)
-                end
+end
+function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
+    return function(____, value)
+        do
+            local function ____catch(e)
+                reject(_G, e)
+            end
+            local ____try, ____hasReturned = pcall(function()
+                self:handleCallbackData(
+                    f(_G, value),
+                    resolve,
+                    reject
+                )
+            end)
+            if not ____try then
+                ____catch(____hasReturned)
             end
         end
     end
-    function __TS__Promise.prototype.handleCallbackData(self, data, resolve, reject)
-        if isPromiseLike(nil, data) then
-            local nextpromise = data
-            if nextpromise.state == 1 then
-                resolve(nil, nextpromise.value)
-            elseif nextpromise.state == 2 then
-                reject(nil, nextpromise.rejectionReason)
-            else
-                data["then"](data, resolve, reject)
-            end
+end
+function __TS__Promise.prototype.handleCallbackData(self, data, resolve, reject)
+    if __TS__IsPromiseLike(_G, data) then
+        local nextpromise = data
+        if nextpromise.state == __TS__PromiseState.Fulfilled then
+            resolve(_G, nextpromise.value)
+        elseif nextpromise.state == __TS__PromiseState.Rejected then
+            reject(_G, nextpromise.rejectionReason)
         else
-            resolve(nil, data)
+            data["then"](data, resolve, reject)
         end
+    else
+        resolve(_G, data)
     end
 end
 
-local function __TS__AsyncAwaiter(generator)
+function __TS__AsyncAwaiter(generator)
     return __TS__New(
         __TS__Promise,
         function(____, resolve, reject)
@@ -724,9 +725,9 @@ local function __TS__AsyncAwaiter(generator)
             function fulfilled(self, value)
                 local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine, value)
                 if success then
-                    step(nil, resultOrError, errorOrErrorHandler)
+                    step(_G, resultOrError, errorOrErrorHandler)
                 else
-                    reject(nil, errorOrErrorHandler)
+                    reject(_G, errorOrErrorHandler)
                 end
             end
             function rejected(self, handler)
@@ -735,47 +736,47 @@ local function __TS__AsyncAwaiter(generator)
                         local success, hasReturnedOrError, returnedValue = pcall(handler, value)
                         if success then
                             if hasReturnedOrError then
-                                resolve(nil, returnedValue)
+                                resolve(_G, returnedValue)
                             else
-                                step(nil, hasReturnedOrError, handler)
+                                step(_G, hasReturnedOrError, handler)
                             end
                         else
-                            reject(nil, hasReturnedOrError)
+                            reject(_G, hasReturnedOrError)
                         end
                     end
                 else
                     return function(____, value)
-                        reject(nil, value)
+                        reject(_G, value)
                     end
                 end
             end
             function step(self, result, errorHandler)
                 if coroutine.status(asyncCoroutine) == "dead" then
-                    resolve(nil, result)
+                    resolve(_G, result)
                 else
-                    local ____self_1 = adopt(nil, result)
+                    local ____self_1 = adopt(_G, result)
                     ____self_1["then"](
                         ____self_1,
                         fulfilled,
-                        rejected(nil, errorHandler)
+                        rejected(_G, errorHandler)
                     )
                 end
             end
             asyncCoroutine = coroutine.create(generator)
             local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine)
             if success then
-                step(nil, resultOrError, errorOrErrorHandler)
+                step(_G, resultOrError, errorOrErrorHandler)
             else
-                reject(nil, errorOrErrorHandler)
+                reject(_G, errorOrErrorHandler)
             end
         end
     )
 end
-local function __TS__Await(errorHandler, thing)
+function __TS__Await(errorHandler, thing)
     return coroutine.yield(errorHandler, thing)
 end
 
-local function __TS__ClassExtends(target, base)
+function __TS__ClassExtends(target, base)
     target.____super = base
     local staticMetatable = setmetatable({__index = base}, base)
     setmetatable(target, staticMetatable)
@@ -800,7 +801,7 @@ local function __TS__ClassExtends(target, base)
     end
 end
 
-local function __TS__CloneDescriptor(____bindingPattern0)
+function __TS__CloneDescriptor(____bindingPattern0)
     local value
     local writable
     local set
@@ -829,7 +830,7 @@ local function __TS__CloneDescriptor(____bindingPattern0)
     return descriptor
 end
 
-local function __TS__ObjectGetOwnPropertyDescriptor(object, key)
+function __TS__ObjectGetOwnPropertyDescriptor(object, key)
     local metatable = getmetatable(object)
     if not metatable then
         return
@@ -840,87 +841,84 @@ local function __TS__ObjectGetOwnPropertyDescriptor(object, key)
     return rawget(metatable, "_descriptors")[key]
 end
 
-local __TS__SetDescriptor
-do
-    local function descriptorIndex(self, key)
-        local value = rawget(self, key)
-        if value ~= nil then
-            return value
-        end
-        local metatable = getmetatable(self)
-        while metatable do
-            local rawResult = rawget(metatable, key)
-            if rawResult ~= nil then
-                return rawResult
-            end
-            local descriptors = rawget(metatable, "_descriptors")
-            if descriptors then
-                local descriptor = descriptors[key]
-                if descriptor then
-                    if descriptor.get then
-                        return descriptor.get(self)
-                    end
-                    return descriptor.value
+function ____descriptorIndex(self, key)
+    local value = rawget(self, key)
+    if value ~= nil then
+        return value
+    end
+    local metatable = getmetatable(self)
+    while metatable do
+        local rawResult = rawget(metatable, key)
+        if rawResult ~= nil then
+            return rawResult
+        end
+        local descriptors = rawget(metatable, "_descriptors")
+        if descriptors then
+            local descriptor = descriptors[key]
+            if descriptor then
+                if descriptor.get then
+                    return descriptor.get(self)
                 end
+                return descriptor.value
             end
-            metatable = getmetatable(metatable)
-        end
-    end
-    local function descriptorNewIndex(self, key, value)
-        local metatable = getmetatable(self)
-        while metatable do
-            local descriptors = rawget(metatable, "_descriptors")
-            if descriptors then
-                local descriptor = descriptors[key]
-                if descriptor then
-                    if descriptor.set then
-                        descriptor.set(self, value)
-                    else
-                        if descriptor.writable == false then
-                            error(
-                                ((("Cannot assign to read only property '" .. key) .. "' of object '") .. tostring(self)) .. "'",
-                                0
-                            )
-                        end
-                        descriptor.value = value
+        end
+        metatable = getmetatable(metatable)
+    end
+end
+function ____descriptorNewindex(self, key, value)
+    local metatable = getmetatable(self)
+    while metatable do
+        local descriptors = rawget(metatable, "_descriptors")
+        if descriptors then
+            local descriptor = descriptors[key]
+            if descriptor then
+                if descriptor.set then
+                    descriptor.set(self, value)
+                else
+                    if descriptor.writable == false then
+                        error(
+                            ((("Cannot assign to read only property '" .. key) .. "' of object '") .. tostring(self)) .. "'",
+                            0
+                        )
                     end
-                    return
+                    descriptor.value = value
                 end
+                return
             end
-            metatable = getmetatable(metatable)
         end
-        rawset(self, key, value)
+        metatable = getmetatable(metatable)
     end
-    function __TS__SetDescriptor(target, key, desc, isPrototype)
-        if isPrototype == nil then
-            isPrototype = false
-        end
-        local ____isPrototype_0
-        if isPrototype then
-            ____isPrototype_0 = target
-        else
-            ____isPrototype_0 = getmetatable(target)
-        end
-        local metatable = ____isPrototype_0
-        if not metatable then
-            metatable = {}
-            setmetatable(target, metatable)
-        end
-        local value = rawget(target, key)
-        if value ~= nil then
-            rawset(target, key, nil)
-        end
-        if not rawget(metatable, "_descriptors") then
-            metatable._descriptors = {}
-        end
-        local descriptor = __TS__CloneDescriptor(desc)
-        metatable._descriptors[key] = descriptor
-        metatable.__index = descriptorIndex
-        metatable.__newindex = descriptorNewIndex
+    rawset(self, key, value)
+end
+function __TS__SetDescriptor(target, key, desc, isPrototype)
+    if isPrototype == nil then
+        isPrototype = false
+    end
+    local ____isPrototype_0
+    if isPrototype then
+        ____isPrototype_0 = target
+    else
+        ____isPrototype_0 = getmetatable(target)
+    end
+    local metatable = ____isPrototype_0
+    if not metatable then
+        metatable = {}
+        setmetatable(target, metatable)
     end
+    local value = rawget(target, key)
+    if value ~= nil then
+        rawset(target, key, nil)
+    end
+    if not rawget(metatable, "_descriptors") then
+        metatable._descriptors = {}
+    end
+    local descriptor = __TS__CloneDescriptor(desc)
+    metatable._descriptors[key] = descriptor
+    metatable.__index = ____descriptorIndex
+    metatable.__newindex = ____descriptorNewindex
 end
 
-local function __TS__ObjectAssign(to, ...)
+function __TS__ObjectAssign(to, ...)
     local sources = {...}
     if to == nil then
         return to
@@ -933,7 +931,7 @@ local function __TS__ObjectAssign(to, ...)
     return to
 end
 
-local function __TS__Decorate(decorators, target, key, desc)
+function __TS__Decorate(decorators, target, key, desc)
     local result = target
     do
         local i = #decorators
@@ -942,11 +940,11 @@ local function __TS__Decorate(decorators, target, key, desc)
             if decorator then
                 local oldResult = result
                 if key == nil then
-                    result = decorator(nil, result)
+                    result = decorator(_G, result)
                 elseif desc == true then
                     local value = rawget(target, key)
                     local descriptor = __TS__ObjectGetOwnPropertyDescriptor(target, key) or ({configurable = true, writable = true, value = value})
-                    local desc = decorator(nil, target, key, descriptor) or descriptor
+                    local desc = decorator(_G, target, key, descriptor) or descriptor
                     local isSimpleValue = desc.configurable == true and desc.writable == true and not desc.get and not desc.set
                     if isSimpleValue then
                         rawset(target, key, desc.value)
@@ -958,9 +956,9 @@ local function __TS__Decorate(decorators, target, key, desc)
                         )
                     end
                 elseif desc == false then
-                    result = decorator(nil, target, key, desc)
+                    result = decorator(_G, target, key, desc)
                 else
-                    result = decorator(nil, target, key)
+                    result = decorator(_G, target, key)
                 end
                 result = result or oldResult
             end
@@ -970,17 +968,124 @@ local function __TS__Decorate(decorators, target, key, desc)
     return result
 end
 
-local function __TS__DecorateParam(paramIndex, decorator)
-    return function(____, target, key) return decorator(nil, target, key, paramIndex) end
+function __TS__DecorateParam(paramIndex, decorator)
+    return function(____, target, key) return decorator(_G, target, key, paramIndex) end
 end
 
-local function __TS__StringAccess(self, index)
+function __TS__ObjectGetOwnPropertyDescriptors(object)
+    local metatable = getmetatable(object)
+    if not metatable then
+        return {}
+    end
+    return rawget(metatable, "_descriptors") or ({})
+end
+
+function __TS__GetErrorStack(self, constructor)
+    local level = 1
+    while true do
+        local info = debug.getinfo(level, "f")
+        level = level + 1
+        if not info then
+            level = 1
+            break
+        elseif info.func == constructor then
+            break
+        end
+    end
+    return debug.traceback(nil, level)
+end
+function __TS__WrapErrorToString(self, getDescription)
+    return function(self)
+        local description = getDescription(self)
+        local caller = debug.getinfo(3, "f")
+        if _VERSION == "Lua 5.1" or caller and caller.func ~= error then
+            return description
+        else
+            return (tostring(description) .. "\n") .. self.stack
+        end
+    end
+end
+function __TS__InitErrorClass(self, Type, name)
+    Type.name = name
+    return setmetatable(
+        Type,
+        {__call = function(____, _self, message) return __TS__New(Type, message) end}
+    )
+end
+local ____TS__InitErrorClass_3 = __TS__InitErrorClass
+local ____G_2 = _G
+____class_0 = __TS__Class()
+____class_0.name = ""
+function ____class_0.prototype.____constructor(self, message)
+    if message == nil then
+        message = ""
+    end
+    self.message = message
+    self.name = "Error"
+    self.stack = __TS__GetErrorStack(_G, self.constructor.new)
+    local metatable = getmetatable(self)
+    if not metatable.__errorToStringPatched then
+        metatable.__errorToStringPatched = true
+        metatable.__tostring = __TS__WrapErrorToString(_G, metatable.__tostring)
+    end
+end
+function ____class_0.prototype.__tostring(self)
+    local ____temp_1
+    if self.message ~= "" then
+        ____temp_1 = (self.name .. ": ") .. self.message
+    else
+        ____temp_1 = self.name
+    end
+    return ____temp_1
+end
+Error = ____TS__InitErrorClass_3(____G_2, ____class_0, "Error")
+for ____, errorName in ipairs({
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+    "TypeError",
+    "URIError"
+}) do
+    local ____G_7 = _G
+    local ____TS__InitErrorClass_6 = __TS__InitErrorClass
+    local ____G_5 = _G
+    local ____class_4 = __TS__Class()
+    ____class_4.name = ____class_4.name
+    __TS__ClassExtends(____class_4, Error)
+    function ____class_4.prototype.____constructor(self, ...)
+        Error.prototype.____constructor(self, ...)
+        self.name = errorName
+    end
+    ____G_7[errorName] = ____TS__InitErrorClass_6(____G_5, ____class_4, errorName)
+end
+
+function __TS__Delete(target, key)
+    local descriptors = __TS__ObjectGetOwnPropertyDescriptors(target)
+    local descriptor = descriptors[key]
+    if descriptor then
+        if not descriptor.configurable then
+            error(
+                __TS__New(
+                    TypeError,
+                    ((("Cannot delete property " .. tostring(key)) .. " of ") .. tostring(target)) .. "."
+                ),
+                0
+            )
+        end
+        descriptors[key] = nil
+        return true
+    end
+    target[key] = nil
+    return true
+end
+
+function __TS__StringAccess(self, index)
     if index >= 0 and index < #self then
         return string.sub(self, index + 1, index + 1)
     end
 end
 
-local function __TS__DelegatedYield(iterable)
+function __TS__DelegatedYield(iterable)
     if type(iterable) == "string" then
         for index = 0, #iterable - 1 do
             coroutine.yield(__TS__StringAccess(iterable, index))
@@ -1015,336 +1120,222 @@ local function __TS__DelegatedYield(iterable)
     end
 end
 
-local function __TS__ObjectGetOwnPropertyDescriptors(object)
-    local metatable = getmetatable(object)
-    if not metatable then
-        return {}
-    end
-    return rawget(metatable, "_descriptors") or ({})
+function __TS__GeneratorIterator(self)
+    return self
 end
-
-local Error, RangeError, ReferenceError, SyntaxError, TypeError, URIError
-do
-    local function getErrorStack(self, constructor)
-        local level = 1
-        while true do
-            local info = debug.getinfo(level, "f")
-            level = level + 1
-            if not info then
-                level = 1
-                break
-            elseif info.func == constructor then
-                break
-            end
-        end
-        return debug.traceback(nil, level)
+function __TS__GeneratorNext(self, ...)
+    local co = self.____coroutine
+    if coroutine.status(co) == "dead" then
+        return {done = true}
     end
-    local function wrapErrorToString(self, getDescription)
-        return function(self)
-            local description = getDescription(self)
-            local caller = debug.getinfo(3, "f")
-            if _VERSION == "Lua 5.1" or caller and caller.func ~= error then
-                return description
-            else
-                return (tostring(description) .. "\n") .. self.stack
-            end
-        end
+    local status, value = coroutine.resume(co, ...)
+    if not status then
+        error(value, 0)
     end
-    local function initErrorClass(self, Type, name)
-        Type.name = name
-        return setmetatable(
-            Type,
-            {__call = function(____, _self, message) return __TS__New(Type, message) end}
-        )
-    end
-    local ____initErrorClass_2 = initErrorClass
-    local ____class_0 = __TS__Class()
-    ____class_0.name = ""
-    function ____class_0.prototype.____constructor(self, message)
-        if message == nil then
-            message = ""
-        end
-        self.message = message
-        self.name = "Error"
-        self.stack = getErrorStack(nil, self.constructor.new)
-        local metatable = getmetatable(self)
-        if not metatable.__errorToStringPatched then
-            metatable.__errorToStringPatched = true
-            metatable.__tostring = wrapErrorToString(nil, metatable.__tostring)
-        end
-    end
-    function ____class_0.prototype.__tostring(self)
-        local ____temp_1
-        if self.message ~= "" then
-            ____temp_1 = (self.name .. ": ") .. self.message
-        else
-            ____temp_1 = self.name
-        end
-        return ____temp_1
-    end
-    Error = ____initErrorClass_2(nil, ____class_0, "Error")
-    local function createErrorClass(self, name)
-        local ____initErrorClass_4 = initErrorClass
-        local ____class_3 = __TS__Class()
-        ____class_3.name = ____class_3.name
-        __TS__ClassExtends(____class_3, Error)
-        function ____class_3.prototype.____constructor(self, ...)
-            ____class_3.____super.prototype.____constructor(self, ...)
-            self.name = name
-        end
-        return ____initErrorClass_4(nil, ____class_3, name)
+    return {
+        value = value,
+        done = coroutine.status(co) == "dead"
+    }
+end
+function __TS__Generator(fn)
+    return function(...)
+        local args = {...}
+        local argsLength = select("#", ...)
+        return {
+            ____coroutine = coroutine.create(function() return fn((unpack or table.unpack)(args, 1, argsLength)) end),
+            [Symbol.iterator] = __TS__GeneratorIterator,
+            next = __TS__GeneratorNext
+        }
     end
-    RangeError = createErrorClass(nil, "RangeError")
-    ReferenceError = createErrorClass(nil, "ReferenceError")
-    SyntaxError = createErrorClass(nil, "SyntaxError")
-    TypeError = createErrorClass(nil, "TypeError")
-    URIError = createErrorClass(nil, "URIError")
 end
 
-local function __TS__Delete(target, key)
-    local descriptors = __TS__ObjectGetOwnPropertyDescriptors(target)
-    local descriptor = descriptors[key]
-    if descriptor then
-        if not descriptor.configurable then
-            error(
-                __TS__New(
-                    TypeError,
-                    ((("Cannot delete property " .. tostring(key)) .. " of ") .. tostring(target)) .. "."
-                ),
-                0
-            )
-        end
-        descriptors[key] = nil
-        return true
-    end
-    target[key] = nil
-    return true
+function __TS__InstanceOfObject(value)
+    local valueType = type(value)
+    return valueType == "table" or valueType == "function"
 end
 
-local __TS__Generator
-do
-    local function generatorIterator(self)
-        return self
+function __TS__IteratorGeneratorStep(self)
+    local co = self.____coroutine
+    local status, value = coroutine.resume(co)
+    if not status then
+        error(value, 0)
     end
-    local function generatorNext(self, ...)
-        local co = self.____coroutine
-        if coroutine.status(co) == "dead" then
-            return {done = true}
-        end
-        local status, value = coroutine.resume(co, ...)
-        if not status then
-            error(value, 0)
-        end
-        return {
-            value = value,
-            done = coroutine.status(co) == "dead"
-        }
+    if coroutine.status(co) == "dead" then
+        return
     end
-    function __TS__Generator(fn)
-        return function(...)
-            local args = {...}
-            local argsLength = select("#", ...)
-            return {
-                ____coroutine = coroutine.create(function() return fn((unpack or table.unpack)(args, 1, argsLength)) end),
-                [Symbol.iterator] = generatorIterator,
-                next = generatorNext
-            }
-        end
+    return true, value
+end
+function __TS__IteratorIteratorStep(self)
+    local result = self:next()
+    if result.done then
+        return
     end
+    return true, result.value
 end
-
-local function __TS__InstanceOfObject(value)
-    local valueType = type(value)
-    return valueType == "table" or valueType == "function"
+function __TS__IteratorStringStep(self, index)
+    index = index + 1
+    if index > #self then
+        return
+    end
+    return index, string.sub(self, index, index)
+end
+function __TS__Iterator(iterable)
+    if type(iterable) == "string" then
+        return __TS__IteratorStringStep, iterable, 0
+    elseif iterable.____coroutine ~= nil then
+        return __TS__IteratorGeneratorStep, iterable
+    elseif iterable[Symbol.iterator] then
+        local iterator = iterable[Symbol.iterator](iterable)
+        return __TS__IteratorIteratorStep, iterator
+    else
+        return ipairs(iterable)
+    end
 end
 
-local __TS__Iterator
-do
-    local function iteratorGeneratorStep(self)
-        local co = self.____coroutine
-        local status, value = coroutine.resume(co)
-        if not status then
-            error(value, 0)
-        end
-        if coroutine.status(co) == "dead" then
-            return
-        end
-        return true, value
-    end
-    local function iteratorIteratorStep(self)
-        local result = self:next()
-        if result.done then
-            return
-        end
-        return true, result.value
-    end
-    local function iteratorStringStep(self, index)
-        index = index + 1
-        if index > #self then
-            return
-        end
-        return index, string.sub(self, index, index)
+Map = __TS__Class()
+Map.name = "Map"
+function Map.prototype.____constructor(self, entries)
+    self[Symbol.toStringTag] = "Map"
+    self.items = {}
+    self.size = 0
+    self.nextKey = {}
+    self.previousKey = {}
+    if entries == nil then
+        return
     end
-    function __TS__Iterator(iterable)
-        if type(iterable) == "string" then
-            return iteratorStringStep, iterable, 0
-        elseif iterable.____coroutine ~= nil then
-            return iteratorGeneratorStep, iterable
-        elseif iterable[Symbol.iterator] then
-            local iterator = iterable[Symbol.iterator](iterable)
-            return iteratorIteratorStep, iterator
-        else
-            return ipairs(iterable)
-        end
-    end
-end
-
-local Map
-do
-    Map = __TS__Class()
-    Map.name = "Map"
-    function Map.prototype.____constructor(self, entries)
-        self[Symbol.toStringTag] = "Map"
-        self.items = {}
-        self.size = 0
-        self.nextKey = {}
-        self.previousKey = {}
-        if entries == nil then
-            return
-        end
-        local iterable = entries
-        if iterable[Symbol.iterator] then
-            local iterator = iterable[Symbol.iterator](iterable)
-            while true do
-                local result = iterator:next()
-                if result.done then
-                    break
-                end
-                local value = result.value
-                self:set(value[1], value[2])
-            end
-        else
-            local array = entries
-            for ____, kvp in ipairs(array) do
-                self:set(kvp[1], kvp[2])
+    local iterable = entries
+    if iterable[Symbol.iterator] then
+        local iterator = iterable[Symbol.iterator](iterable)
+        while true do
+            local result = iterator:next()
+            if result.done then
+                break
             end
+            local value = result.value
+            self:set(value[1], value[2])
         end
-    end
-    function Map.prototype.clear(self)
-        self.items = {}
-        self.nextKey = {}
-        self.previousKey = {}
-        self.firstKey = nil
-        self.lastKey = nil
-        self.size = 0
-    end
-    function Map.prototype.delete(self, key)
-        local contains = self:has(key)
-        if contains then
-            self.size = self.size - 1
-            local next = self.nextKey[key]
-            local previous = self.previousKey[key]
-            if next and previous then
-                self.nextKey[previous] = next
-                self.previousKey[next] = previous
-            elseif next then
-                self.firstKey = next
-                self.previousKey[next] = nil
-            elseif previous then
-                self.lastKey = previous
-                self.nextKey[previous] = nil
-            else
-                self.firstKey = nil
-                self.lastKey = nil
-            end
-            self.nextKey[key] = nil
-            self.previousKey[key] = nil
+    else
+        local array = entries
+        for ____, kvp in ipairs(array) do
+            self:set(kvp[1], kvp[2])
+        end
+    end
+end
+function Map.prototype.clear(self)
+    self.items = {}
+    self.nextKey = {}
+    self.previousKey = {}
+    self.firstKey = nil
+    self.lastKey = nil
+    self.size = 0
+end
+function Map.prototype.delete(self, key)
+    local contains = self:has(key)
+    if contains then
+        self.size = self.size - 1
+        local next = self.nextKey[key]
+        local previous = self.previousKey[key]
+        if next and previous then
+            self.nextKey[previous] = next
+            self.previousKey[next] = previous
+        elseif next then
+            self.firstKey = next
+            self.previousKey[next] = nil
+        elseif previous then
+            self.lastKey = previous
+            self.nextKey[previous] = nil
+        else
+            self.firstKey = nil
+            self.lastKey = nil
         end
-        self.items[key] = nil
-        return contains
+        self.nextKey[key] = nil
+        self.previousKey[key] = nil
     end
-    function Map.prototype.forEach(self, callback)
-        for ____, key in __TS__Iterator(self:keys()) do
-            callback(nil, self.items[key], key, self)
-        end
+    self.items[key] = nil
+    return contains
+end
+function Map.prototype.forEach(self, callback)
+    for ____, key in __TS__Iterator(self:keys()) do
+        callback(_G, self.items[key], key, self)
     end
-    function Map.prototype.get(self, key)
-        return self.items[key]
+end
+function Map.prototype.get(self, key)
+    return self.items[key]
+end
+function Map.prototype.has(self, key)
+    return self.nextKey[key] ~= nil or self.lastKey == key
+end
+function Map.prototype.set(self, key, value)
+    local isNewValue = not self:has(key)
+    if isNewValue then
+        self.size = self.size + 1
     end
-    function Map.prototype.has(self, key)
-        return self.nextKey[key] ~= nil or self.lastKey == key
+    self.items[key] = value
+    if self.firstKey == nil then
+        self.firstKey = key
+        self.lastKey = key
+    elseif isNewValue then
+        self.nextKey[self.lastKey] = key
+        self.previousKey[key] = self.lastKey
+        self.lastKey = key
     end
-    function Map.prototype.set(self, key, value)
-        local isNewValue = not self:has(key)
-        if isNewValue then
-            self.size = self.size + 1
+    return self
+end
+Map.prototype[Symbol.iterator] = function(self)
+    return self:entries()
+end
+function Map.prototype.entries(self)
+    local ____temp_0 = self
+    local items = ____temp_0.items
+    local nextKey = ____temp_0.nextKey
+    local key = self.firstKey
+    return {
+        [Symbol.iterator] = function(self)
+            return self
+        end,
+        next = function(self)
+            local result = {done = not key, value = {key, items[key]}}
+            key = nextKey[key]
+            return result
         end
-        self.items[key] = value
-        if self.firstKey == nil then
-            self.firstKey = key
-            self.lastKey = key
-        elseif isNewValue then
-            self.nextKey[self.lastKey] = key
-            self.previousKey[key] = self.lastKey
-            self.lastKey = key
+    }
+end
+function Map.prototype.keys(self)
+    local nextKey = self.nextKey
+    local key = self.firstKey
+    return {
+        [Symbol.iterator] = function(self)
+            return self
+        end,
+        next = function(self)
+            local result = {done = not key, value = key}
+            key = nextKey[key]
+            return result
         end
-        return self
-    end
-    Map.prototype[Symbol.iterator] = function(self)
-        return self:entries()
-    end
-    function Map.prototype.entries(self)
-        local ____temp_0 = self
-        local items = ____temp_0.items
-        local nextKey = ____temp_0.nextKey
-        local key = self.firstKey
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                local result = {done = not key, value = {key, items[key]}}
-                key = nextKey[key]
-                return result
-            end
-        }
-    end
-    function Map.prototype.keys(self)
-        local nextKey = self.nextKey
-        local key = self.firstKey
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                local result = {done = not key, value = key}
-                key = nextKey[key]
-                return result
-            end
-        }
-    end
-    function Map.prototype.values(self)
-        local ____temp_1 = self
-        local items = ____temp_1.items
-        local nextKey = ____temp_1.nextKey
-        local key = self.firstKey
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                local result = {done = not key, value = items[key]}
-                key = nextKey[key]
-                return result
-            end
-        }
-    end
-    Map[Symbol.species] = Map
+    }
 end
+function Map.prototype.values(self)
+    local ____temp_1 = self
+    local items = ____temp_1.items
+    local nextKey = ____temp_1.nextKey
+    local key = self.firstKey
+    return {
+        [Symbol.iterator] = function(self)
+            return self
+        end,
+        next = function(self)
+            local result = {done = not key, value = items[key]}
+            key = nextKey[key]
+            return result
+        end
+    }
+end
+Map[Symbol.species] = Map
+Map = Map
 
-local __TS__MathAtan2 = math.atan2 or math.atan
+__TS__MathAtan2 = math.atan2 or math.atan
 
-local function __TS__MathSign(val)
+function __TS__MathSign(val)
     if val > 0 then
         return 1
     elseif val < 0 then
@@ -1353,7 +1344,7 @@ local function __TS__MathSign(val)
     return 0
 end
 
-local function __TS__Number(value)
+function __TS__Number(value)
     local valueType = type(value)
     if valueType == "number" then
         return value
@@ -1380,60 +1371,57 @@ local function __TS__Number(value)
     end
 end
 
-local function __TS__NumberIsFinite(value)
+function __TS__NumberIsFinite(value)
     return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
 end
 
-local function __TS__NumberIsNaN(value)
+function __TS__NumberIsNaN(value)
     return value ~= value
 end
 
-local __TS__NumberToString
-do
-    local radixChars = "0123456789abcdefghijklmnopqrstuvwxyz"
-    function __TS__NumberToString(self, radix)
-        if radix == nil or radix == 10 or self == math.huge or self == -math.huge or self ~= self then
-            return tostring(self)
-        end
-        radix = math.floor(radix)
-        if radix < 2 or radix > 36 then
-            error("toString() radix argument must be between 2 and 36", 0)
-        end
-        local integer, fraction = math.modf(math.abs(self))
-        local result = ""
-        if radix == 8 then
-            result = string.format("%o", integer)
-        elseif radix == 16 then
-            result = string.format("%x", integer)
-        else
-            repeat
-                do
-                    result = __TS__StringAccess(radixChars, integer % radix) .. result
-                    integer = math.floor(integer / radix)
-                end
-            until not (integer ~= 0)
-        end
-        if fraction ~= 0 then
-            result = result .. "."
-            local delta = 1e-16
-            repeat
-                do
-                    fraction = fraction * radix
-                    delta = delta * radix
-                    local digit = math.floor(fraction)
-                    result = result .. __TS__StringAccess(radixChars, digit)
-                    fraction = fraction - digit
-                end
-            until not (fraction >= delta)
-        end
-        if self < 0 then
-            result = "-" .. result
-        end
-        return result
+____radixChars = "0123456789abcdefghijklmnopqrstuvwxyz"
+function __TS__NumberToString(self, radix)
+    if radix == nil or radix == 10 or self == math.huge or self == -math.huge or self ~= self then
+        return tostring(self)
     end
+    radix = math.floor(radix)
+    if radix < 2 or radix > 36 then
+        error("toString() radix argument must be between 2 and 36", 0)
+    end
+    local integer, fraction = math.modf(math.abs(self))
+    local result = ""
+    if radix == 8 then
+        result = string.format("%o", integer)
+    elseif radix == 16 then
+        result = string.format("%x", integer)
+    else
+        repeat
+            do
+                result = __TS__StringAccess(____radixChars, integer % radix) .. result
+                integer = math.floor(integer / radix)
+            end
+        until not (integer ~= 0)
+    end
+    if fraction ~= 0 then
+        result = result .. "."
+        local delta = 1e-16
+        repeat
+            do
+                fraction = fraction * radix
+                delta = delta * radix
+                local digit = math.floor(fraction)
+                result = result .. __TS__StringAccess(____radixChars, digit)
+                fraction = fraction - digit
+            end
+        until not (fraction >= delta)
+    end
+    if self < 0 then
+        result = "-" .. result
+    end
+    return result
 end
 
-local function __TS__ObjectDefineProperty(target, key, desc)
+function __TS__ObjectDefineProperty(target, key, desc)
     local ____temp_0
     if type(key) == "number" then
         ____temp_0 = key + 1
@@ -1493,7 +1481,7 @@ local function __TS__ObjectDefineProperty(target, key, desc)
     return target
 end
 
-local function __TS__ObjectEntries(obj)
+function __TS__ObjectEntries(obj)
     local result = {}
     for key in pairs(obj) do
         result[#result + 1] = {key, obj[key]}
@@ -1501,7 +1489,7 @@ local function __TS__ObjectEntries(obj)
     return result
 end
 
-local function __TS__ObjectFromEntries(entries)
+function __TS__ObjectFromEntries(entries)
     local obj = {}
     local iterable = entries
     if iterable[Symbol.iterator] then
@@ -1522,7 +1510,7 @@ local function __TS__ObjectFromEntries(entries)
     return obj
 end
 
-local function __TS__ObjectKeys(obj)
+function __TS__ObjectKeys(obj)
     local result = {}
     for key in pairs(obj) do
         result[#result + 1] = key
@@ -1530,7 +1518,7 @@ local function __TS__ObjectKeys(obj)
     return result
 end
 
-local function __TS__ObjectRest(target, usedProperties)
+function __TS__ObjectRest(target, usedProperties)
     local result = {}
     for property in pairs(target) do
         if not usedProperties[property] then
@@ -1540,7 +1528,7 @@ local function __TS__ObjectRest(target, usedProperties)
     return result
 end
 
-local function __TS__ObjectValues(obj)
+function __TS__ObjectValues(obj)
     local result = {}
     for key in pairs(obj) do
         result[#result + 1] = obj[key]
@@ -1548,7 +1536,7 @@ local function __TS__ObjectValues(obj)
     return result
 end
 
-local function __TS__ParseFloat(numberString)
+function __TS__ParseFloat(numberString)
     local infinityMatch = string.match(numberString, "^%s*(-?Infinity)")
     if infinityMatch then
         local ____temp_0
@@ -1563,7 +1551,7 @@ local function __TS__ParseFloat(numberString)
     return number or 0 / 0
 end
 
-local function __TS__StringSubstr(self, from, length)
+function __TS__StringSubstr(self, from, length)
     if from ~= from then
         from = 0
     end
@@ -1579,7 +1567,7 @@ local function __TS__StringSubstr(self, from, length)
     return string.sub(self, from, length)
 end
 
-local function __TS__StringSubstring(self, start, ____end)
+function __TS__StringSubstring(self, start, ____end)
     if ____end ~= ____end then
         ____end = 0
     end
@@ -1597,60 +1585,57 @@ local function __TS__StringSubstring(self, start, ____end)
     return string.sub(self, start, ____end)
 end
 
-local __TS__ParseInt
-do
-    local parseIntBasePattern = "0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTvVwWxXyYzZ"
-    function __TS__ParseInt(numberString, base)
-        if base == nil then
-            base = 10
-            local hexMatch = string.match(numberString, "^%s*-?0[xX]")
-            if hexMatch then
-                base = 16
-                local ____string_match_result__0_0
-                if string.match(hexMatch, "-") then
-                    ____string_match_result__0_0 = "-" .. __TS__StringSubstr(numberString, #hexMatch)
-                else
-                    ____string_match_result__0_0 = __TS__StringSubstr(numberString, #hexMatch)
-                end
-                numberString = ____string_match_result__0_0
+__TS__parseInt_base_pattern = "0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTvVwWxXyYzZ"
+function __TS__ParseInt(numberString, base)
+    if base == nil then
+        base = 10
+        local hexMatch = string.match(numberString, "^%s*-?0[xX]")
+        if hexMatch then
+            base = 16
+            local ____string_match_result__0_0
+            if string.match(hexMatch, "-") then
+                ____string_match_result__0_0 = "-" .. __TS__StringSubstr(numberString, #hexMatch)
+            else
+                ____string_match_result__0_0 = __TS__StringSubstr(numberString, #hexMatch)
             end
+            numberString = ____string_match_result__0_0
         end
-        if base < 2 or base > 36 then
-            return 0 / 0
-        end
-        local ____temp_1
-        if base <= 10 then
-            ____temp_1 = __TS__StringSubstring(parseIntBasePattern, 0, base)
-        else
-            ____temp_1 = __TS__StringSubstr(parseIntBasePattern, 0, 10 + 2 * (base - 10))
-        end
-        local allowedDigits = ____temp_1
-        local pattern = ("^%s*(-?[" .. allowedDigits) .. "]*)"
-        local number = tonumber(
-            string.match(numberString, pattern),
-            base
-        )
-        if number == nil then
-            return 0 / 0
-        end
-        if number >= 0 then
-            return math.floor(number)
-        else
-            return math.ceil(number)
-        end
+    end
+    if base < 2 or base > 36 then
+        return 0 / 0
+    end
+    local ____temp_1
+    if base <= 10 then
+        ____temp_1 = __TS__StringSubstring(__TS__parseInt_base_pattern, 0, base)
+    else
+        ____temp_1 = __TS__StringSubstr(__TS__parseInt_base_pattern, 0, 10 + 2 * (base - 10))
+    end
+    local allowedDigits = ____temp_1
+    local pattern = ("^%s*(-?[" .. allowedDigits) .. "]*)"
+    local number = tonumber(
+        string.match(numberString, pattern),
+        base
+    )
+    if number == nil then
+        return 0 / 0
+    end
+    if number >= 0 then
+        return math.floor(number)
+    else
+        return math.ceil(number)
     end
 end
 
-local function __TS__PromiseAll(iterable)
+function __TS__PromiseAll(iterable)
     local results = {}
     local toResolve = {}
     local numToResolve = 0
     local i = 0
     for ____, item in __TS__Iterator(iterable) do
         if __TS__InstanceOf(item, __TS__Promise) then
-            if item.state == 1 then
+            if item.state == __TS__PromiseState.Fulfilled then
                 results[i + 1] = item.value
-            elseif item.state == 2 then
+            elseif item.state == __TS__PromiseState.Rejected then
                 return __TS__Promise.reject(item.rejectionReason)
             else
                 numToResolve = numToResolve + 1
@@ -1674,11 +1659,11 @@ local function __TS__PromiseAll(iterable)
                         results[index + 1] = data
                         numToResolve = numToResolve - 1
                         if numToResolve == 0 then
-                            resolve(nil, results)
+                            resolve(_G, results)
                         end
                     end,
                     function(____, reason)
-                        reject(nil, reason)
+                        reject(_G, reason)
                     end
                 )
             end
@@ -1686,16 +1671,16 @@ local function __TS__PromiseAll(iterable)
     )
 end
 
-local function __TS__PromiseAllSettled(iterable)
+function __TS__PromiseAllSettled(iterable)
     local results = {}
     local toResolve = {}
     local numToResolve = 0
     local i = 0
     for ____, item in __TS__Iterator(iterable) do
         if __TS__InstanceOf(item, __TS__Promise) then
-            if item.state == 1 then
+            if item.state == __TS__PromiseState.Fulfilled then
                 results[i + 1] = {status = "fulfilled", value = item.value}
-            elseif item.state == 2 then
+            elseif item.state == __TS__PromiseState.Rejected then
                 results[i + 1] = {status = "rejected", reason = item.rejectionReason}
             else
                 numToResolve = numToResolve + 1
@@ -1719,14 +1704,14 @@ local function __TS__PromiseAllSettled(iterable)
                         results[index + 1] = {status = "fulfilled", value = data}
                         numToResolve = numToResolve - 1
                         if numToResolve == 0 then
-                            resolve(nil, results)
+                            resolve(_G, results)
                         end
                     end,
                     function(____, reason)
                         results[index + 1] = {status = "rejected", reason = reason}
                         numToResolve = numToResolve - 1
                         if numToResolve == 0 then
-                            resolve(nil, results)
+                            resolve(_G, results)
                         end
                     end
                 )
@@ -1735,14 +1720,14 @@ local function __TS__PromiseAllSettled(iterable)
     )
 end
 
-local function __TS__PromiseAny(iterable)
+function __TS__PromiseAny(iterable)
     local rejections = {}
     local pending = {}
     for ____, item in __TS__Iterator(iterable) do
         if __TS__InstanceOf(item, __TS__Promise) then
-            if item.state == 1 then
+            if item.state == __TS__PromiseState.Fulfilled then
                 return __TS__Promise.resolve(item.value)
-            elseif item.state == 2 then
+            elseif item.state == __TS__PromiseState.Rejected then
                 __TS__ArrayPush(rejections, item.rejectionReason)
             else
                 __TS__ArrayPush(pending, item)
@@ -1762,13 +1747,13 @@ local function __TS__PromiseAny(iterable)
                 promise["then"](
                     promise,
                     function(____, data)
-                        resolve(nil, data)
+                        resolve(_G, data)
                     end,
                     function(____, reason)
                         __TS__ArrayPush(rejections, reason)
                         numResolved = numResolved + 1
                         if numResolved == #pending then
-                            reject(nil, {name = "AggregateError", message = "All Promises rejected", errors = rejections})
+                            reject(_G, {name = "AggregateError", message = "All Promises rejected", errors = rejections})
                         end
                     end
                 )
@@ -1777,13 +1762,13 @@ local function __TS__PromiseAny(iterable)
     )
 end
 
-local function __TS__PromiseRace(iterable)
+function __TS__PromiseRace(iterable)
     local pending = {}
     for ____, item in __TS__Iterator(iterable) do
         if __TS__InstanceOf(item, __TS__Promise) then
-            if item.state == 1 then
+            if item.state == __TS__PromiseState.Fulfilled then
                 return __TS__Promise.resolve(item.value)
-            elseif item.state == 2 then
+            elseif item.state == __TS__PromiseState.Rejected then
                 return __TS__Promise.reject(item.rejectionReason)
             else
                 __TS__ArrayPush(pending, item)
@@ -1798,157 +1783,259 @@ local function __TS__PromiseRace(iterable)
             for ____, promise in ipairs(pending) do
                 promise["then"](
                     promise,
-                    function(____, value) return resolve(nil, value) end,
-                    function(____, reason) return reject(nil, reason) end
+                    function(____, value) return resolve(_G, value) end,
+                    function(____, reason) return reject(_G, reason) end
                 )
             end
         end
     )
 end
 
-local Set
-do
-    Set = __TS__Class()
-    Set.name = "Set"
-    function Set.prototype.____constructor(self, values)
-        self[Symbol.toStringTag] = "Set"
-        self.size = 0
-        self.nextKey = {}
-        self.previousKey = {}
-        if values == nil then
-            return
-        end
-        local iterable = values
-        if iterable[Symbol.iterator] then
-            local iterator = iterable[Symbol.iterator](iterable)
-            while true do
-                local result = iterator:next()
-                if result.done then
-                    break
-                end
-                self:add(result.value)
+Set = __TS__Class()
+Set.name = "Set"
+function Set.prototype.____constructor(self, values)
+    self[Symbol.toStringTag] = "Set"
+    self.size = 0
+    self.nextKey = {}
+    self.previousKey = {}
+    if values == nil then
+        return
+    end
+    local iterable = values
+    if iterable[Symbol.iterator] then
+        local iterator = iterable[Symbol.iterator](iterable)
+        while true do
+            local result = iterator:next()
+            if result.done then
+                break
             end
+            self:add(result.value)
+        end
+    else
+        local array = values
+        for ____, value in ipairs(array) do
+            self:add(value)
+        end
+    end
+end
+function Set.prototype.add(self, value)
+    local isNewValue = not self:has(value)
+    if isNewValue then
+        self.size = self.size + 1
+    end
+    if self.firstKey == nil then
+        self.firstKey = value
+        self.lastKey = value
+    elseif isNewValue then
+        self.nextKey[self.lastKey] = value
+        self.previousKey[value] = self.lastKey
+        self.lastKey = value
+    end
+    return self
+end
+function Set.prototype.clear(self)
+    self.nextKey = {}
+    self.previousKey = {}
+    self.firstKey = nil
+    self.lastKey = nil
+    self.size = 0
+end
+function Set.prototype.delete(self, value)
+    local contains = self:has(value)
+    if contains then
+        self.size = self.size - 1
+        local next = self.nextKey[value]
+        local previous = self.previousKey[value]
+        if next and previous then
+            self.nextKey[previous] = next
+            self.previousKey[next] = previous
+        elseif next then
+            self.firstKey = next
+            self.previousKey[next] = nil
+        elseif previous then
+            self.lastKey = previous
+            self.nextKey[previous] = nil
         else
-            local array = values
-            for ____, value in ipairs(array) do
-                self:add(value)
-            end
+            self.firstKey = nil
+            self.lastKey = nil
         end
+        self.nextKey[value] = nil
+        self.previousKey[value] = nil
     end
-    function Set.prototype.add(self, value)
-        local isNewValue = not self:has(value)
-        if isNewValue then
-            self.size = self.size + 1
-        end
-        if self.firstKey == nil then
-            self.firstKey = value
-            self.lastKey = value
-        elseif isNewValue then
-            self.nextKey[self.lastKey] = value
-            self.previousKey[value] = self.lastKey
-            self.lastKey = value
-        end
-        return self
+    return contains
+end
+function Set.prototype.forEach(self, callback)
+    for ____, key in __TS__Iterator(self:keys()) do
+        callback(_G, key, key, self)
     end
-    function Set.prototype.clear(self)
-        self.nextKey = {}
-        self.previousKey = {}
-        self.firstKey = nil
-        self.lastKey = nil
-        self.size = 0
-    end
-    function Set.prototype.delete(self, value)
-        local contains = self:has(value)
-        if contains then
-            self.size = self.size - 1
-            local next = self.nextKey[value]
-            local previous = self.previousKey[value]
-            if next and previous then
-                self.nextKey[previous] = next
-                self.previousKey[next] = previous
-            elseif next then
-                self.firstKey = next
-                self.previousKey[next] = nil
-            elseif previous then
-                self.lastKey = previous
-                self.nextKey[previous] = nil
-            else
-                self.firstKey = nil
-                self.lastKey = nil
-            end
-            self.nextKey[value] = nil
-            self.previousKey[value] = nil
+end
+function Set.prototype.has(self, value)
+    return self.nextKey[value] ~= nil or self.lastKey == value
+end
+Set.prototype[Symbol.iterator] = function(self)
+    return self:values()
+end
+function Set.prototype.entries(self)
+    local nextKey = self.nextKey
+    local key = self.firstKey
+    return {
+        [Symbol.iterator] = function(self)
+            return self
+        end,
+        next = function(self)
+            local result = {done = not key, value = {key, key}}
+            key = nextKey[key]
+            return result
         end
-        return contains
-    end
-    function Set.prototype.forEach(self, callback)
-        for ____, key in __TS__Iterator(self:keys()) do
-            callback(nil, key, key, self)
+    }
+end
+function Set.prototype.keys(self)
+    local nextKey = self.nextKey
+    local key = self.firstKey
+    return {
+        [Symbol.iterator] = function(self)
+            return self
+        end,
+        next = function(self)
+            local result = {done = not key, value = key}
+            key = nextKey[key]
+            return result
         end
+    }
+end
+function Set.prototype.values(self)
+    local nextKey = self.nextKey
+    local key = self.firstKey
+    return {
+        [Symbol.iterator] = function(self)
+            return self
+        end,
+        next = function(self)
+            local result = {done = not key, value = key}
+            key = nextKey[key]
+            return result
+        end
+    }
+end
+Set[Symbol.species] = Set
+Set = Set
+
+function __TS__SparseArrayNew(...)
+    local sparseArray = {...}
+    sparseArray.sparseLength = select("#", ...)
+    return sparseArray
+end
+
+function __TS__SparseArrayPush(sparseArray, ...)
+    local args = {...}
+    local argsLen = select("#", ...)
+    local listLen = sparseArray.sparseLength
+    for i = 1, argsLen do
+        sparseArray[listLen + i] = args[i]
     end
-    function Set.prototype.has(self, value)
-        return self.nextKey[value] ~= nil or self.lastKey == value
-    end
-    Set.prototype[Symbol.iterator] = function(self)
-        return self:values()
+    sparseArray.sparseLength = listLen + argsLen
+end
+
+function __TS__SparseArraySpread(sparseArray)
+    local _unpack = unpack or table.unpack
+    return _unpack(sparseArray, 1, sparseArray.sparseLength)
+end
+
+WeakMap = __TS__Class()
+WeakMap.name = "WeakMap"
+function WeakMap.prototype.____constructor(self, entries)
+    self[Symbol.toStringTag] = "WeakMap"
+    self.items = {}
+    setmetatable(self.items, {__mode = "k"})
+    if entries == nil then
+        return
     end
-    function Set.prototype.entries(self)
-        local nextKey = self.nextKey
-        local key = self.firstKey
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                local result = {done = not key, value = {key, key}}
-                key = nextKey[key]
-                return result
+    local iterable = entries
+    if iterable[Symbol.iterator] then
+        local iterator = iterable[Symbol.iterator](iterable)
+        while true do
+            local result = iterator:next()
+            if result.done then
+                break
             end
-        }
+            local value = result.value
+            self.items[value[1]] = value[2]
+        end
+    else
+        for ____, kvp in ipairs(entries) do
+            self.items[kvp[1]] = kvp[2]
+        end
     end
-    function Set.prototype.keys(self)
-        local nextKey = self.nextKey
-        local key = self.firstKey
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                local result = {done = not key, value = key}
-                key = nextKey[key]
-                return result
-            end
-        }
+end
+function WeakMap.prototype.delete(self, key)
+    local contains = self:has(key)
+    self.items[key] = nil
+    return contains
+end
+function WeakMap.prototype.get(self, key)
+    return self.items[key]
+end
+function WeakMap.prototype.has(self, key)
+    return self.items[key] ~= nil
+end
+function WeakMap.prototype.set(self, key, value)
+    self.items[key] = value
+    return self
+end
+WeakMap[Symbol.species] = WeakMap
+WeakMap = WeakMap
+
+WeakSet = __TS__Class()
+WeakSet.name = "WeakSet"
+function WeakSet.prototype.____constructor(self, values)
+    self[Symbol.toStringTag] = "WeakSet"
+    self.items = {}
+    setmetatable(self.items, {__mode = "k"})
+    if values == nil then
+        return
     end
-    function Set.prototype.values(self)
-        local nextKey = self.nextKey
-        local key = self.firstKey
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                local result = {done = not key, value = key}
-                key = nextKey[key]
-                return result
+    local iterable = values
+    if iterable[Symbol.iterator] then
+        local iterator = iterable[Symbol.iterator](iterable)
+        while true do
+            local result = iterator:next()
+            if result.done then
+                break
             end
-        }
+            self.items[result.value] = true
+        end
+    else
+        for ____, value in ipairs(values) do
+            self.items[value] = true
+        end
     end
-    Set[Symbol.species] = Set
 end
+function WeakSet.prototype.add(self, value)
+    self.items[value] = true
+    return self
+end
+function WeakSet.prototype.delete(self, value)
+    local contains = self:has(value)
+    self.items[value] = nil
+    return contains
+end
+function WeakSet.prototype.has(self, value)
+    return self.items[value] == true
+end
+WeakSet[Symbol.species] = WeakSet
+WeakSet = WeakSet
 
-local function __TS__SourceMapTraceBack(fileName, sourceMap)
+function __TS__SourceMapTraceBack(fileName, sourceMap)
     _G.__TS__sourcemap = _G.__TS__sourcemap or ({})
     _G.__TS__sourcemap[fileName] = sourceMap
     if _G.__TS__originalTraceback == nil then
-        local originalTraceback = debug.traceback
-        _G.__TS__originalTraceback = originalTraceback
+        _G.__TS__originalTraceback = debug.traceback
         debug.traceback = function(thread, message, level)
             local trace
             if thread == nil and message == nil and level == nil then
-                trace = originalTraceback()
+                trace = _G.__TS__originalTraceback()
             else
-                trace = originalTraceback(thread, message, level)
+                trace = _G.__TS__originalTraceback(thread, message, level)
             end
             if type(trace) ~= "string" then
                 return trace
@@ -1967,40 +2054,19 @@ local function __TS__SourceMapTraceBack(fileName, sourceMap)
             local result = string.gsub(
                 trace,
                 "(%S+)%.lua:(%d+)",
-                function(file, line) return replacer(nil, file .. ".lua", file .. ".ts", line) end
+                function(file, line) return replacer(_G, file .. ".lua", file .. ".ts", line) end
             )
             result = string.gsub(
                 result,
                 "(%[string \"[^\"]+\"%]):(%d+)",
-                function(file, line) return replacer(nil, file, "unknown", line) end
+                function(file, line) return replacer(_G, file, "unknown", line) end
             )
             return result
         end
     end
 end
 
-local function __TS__SparseArrayNew(...)
-    local sparseArray = {...}
-    sparseArray.sparseLength = select("#", ...)
-    return sparseArray
-end
-
-local function __TS__SparseArrayPush(sparseArray, ...)
-    local args = {...}
-    local argsLen = select("#", ...)
-    local listLen = sparseArray.sparseLength
-    for i = 1, argsLen do
-        sparseArray[listLen + i] = args[i]
-    end
-    sparseArray.sparseLength = listLen + argsLen
-end
-
-local function __TS__SparseArraySpread(sparseArray)
-    local _unpack = unpack or table.unpack
-    return _unpack(sparseArray, 1, sparseArray.sparseLength)
-end
-
-local function __TS__Spread(iterable)
+function __TS__Spread(iterable)
     local arr = {}
     if type(iterable) == "string" then
         do
@@ -2018,7 +2084,7 @@ local function __TS__Spread(iterable)
     return __TS__Unpack(arr)
 end
 
-local function __TS__StringCharAt(self, pos)
+function __TS__StringCharAt(self, pos)
     if pos ~= pos then
         pos = 0
     end
@@ -2028,7 +2094,7 @@ local function __TS__StringCharAt(self, pos)
     return string.sub(self, pos + 1, pos + 1)
 end
 
-local function __TS__StringCharCodeAt(self, index)
+function __TS__StringCharCodeAt(self, index)
     if index ~= index then
         index = 0
     end
@@ -2038,7 +2104,7 @@ local function __TS__StringCharCodeAt(self, index)
     return string.byte(self, index + 1) or 0 / 0
 end
 
-local function __TS__StringConcat(str1, ...)
+function __TS__StringConcat(str1, ...)
     local args = {...}
     local out = str1
     for ____, arg in ipairs(args) do
@@ -2047,14 +2113,14 @@ local function __TS__StringConcat(str1, ...)
     return out
 end
 
-local function __TS__StringEndsWith(self, searchString, endPosition)
+function __TS__StringEndsWith(self, searchString, endPosition)
     if endPosition == nil or endPosition > #self then
         endPosition = #self
     end
     return string.sub(self, endPosition - #searchString + 1, endPosition) == searchString
 end
 
-local function __TS__StringIncludes(self, searchString, position)
+function __TS__StringIncludes(self, searchString, position)
     if not position then
         position = 1
     else
@@ -2064,7 +2130,7 @@ local function __TS__StringIncludes(self, searchString, position)
     return index ~= nil
 end
 
-local function __TS__StringPadEnd(self, maxLength, fillString)
+function __TS__StringPadEnd(self, maxLength, fillString)
     if fillString == nil then
         fillString = " "
     end
@@ -2091,7 +2157,7 @@ local function __TS__StringPadEnd(self, maxLength, fillString)
     )
 end
 
-local function __TS__StringPadStart(self, maxLength, fillString)
+function __TS__StringPadStart(self, maxLength, fillString)
     if fillString == nil then
         fillString = " "
     end
@@ -2118,7 +2184,7 @@ local function __TS__StringPadStart(self, maxLength, fillString)
     ) .. self
 end
 
-local function __TS__StringReplace(source, searchValue, replaceValue)
+function __TS__StringReplace(source, searchValue, replaceValue)
     local startPos, endPos = string.find(source, searchValue, nil, true)
     if not startPos then
         return source
@@ -2129,14 +2195,14 @@ local function __TS__StringReplace(source, searchValue, replaceValue)
     if type(replaceValue) == "string" then
         ____temp_0 = replaceValue
     else
-        ____temp_0 = replaceValue(nil, searchValue, startPos - 1, source)
+        ____temp_0 = replaceValue(_G, searchValue, startPos - 1, source)
     end
     local replacement = ____temp_0
     local after = sub(source, endPos + 1)
     return (before .. replacement) .. after
 end
 
-local function __TS__StringReplaceAll(source, searchValue, replaceValue)
+function __TS__StringReplaceAll(source, searchValue, replaceValue)
     local replacer
     if type(replaceValue) == "string" then
         replacer = function() return replaceValue end
@@ -2147,11 +2213,11 @@ local function __TS__StringReplaceAll(source, searchValue, replaceValue)
     local partsIndex = 1
     local sub = string.sub
     if #searchValue == 0 then
-        parts[1] = replacer(nil, "", 0, source)
+        parts[1] = replacer(_G, "", 0, source)
         partsIndex = 2
         for i = 1, #source do
             parts[partsIndex] = sub(source, i, i)
-            parts[partsIndex + 1] = replacer(nil, "", i, source)
+            parts[partsIndex + 1] = replacer(_G, "", i, source)
             partsIndex = partsIndex + 2
         end
     else
@@ -2163,7 +2229,7 @@ local function __TS__StringReplaceAll(source, searchValue, replaceValue)
                 break
             end
             parts[partsIndex] = sub(source, currentPos, startPos - 1)
-            parts[partsIndex + 1] = replacer(nil, searchValue, startPos - 1, source)
+            parts[partsIndex + 1] = replacer(_G, searchValue, startPos - 1, source)
             partsIndex = partsIndex + 2
             currentPos = endPos + 1
         end
@@ -2172,7 +2238,7 @@ local function __TS__StringReplaceAll(source, searchValue, replaceValue)
     return table.concat(parts)
 end
 
-local function __TS__StringSlice(self, start, ____end)
+function __TS__StringSlice(self, start, ____end)
     if start == nil or start ~= start then
         start = 0
     end
@@ -2188,7 +2254,7 @@ local function __TS__StringSlice(self, start, ____end)
     return string.sub(self, start, ____end)
 end
 
-local function __TS__StringSplit(source, separator, limit)
+function __TS__StringSplit(source, separator, limit)
     if limit == nil then
         limit = 4294967295
     end
@@ -2225,47 +2291,44 @@ local function __TS__StringSplit(source, separator, limit)
     return out
 end
 
-local function __TS__StringStartsWith(self, searchString, position)
+function __TS__StringStartsWith(self, searchString, position)
     if position == nil or position < 0 then
         position = 0
     end
     return string.sub(self, position + 1, #searchString + position) == searchString
 end
 
-local function __TS__StringTrim(self)
+function __TS__StringTrim(self)
     local result = string.gsub(self, "^[%s ]*(.-)[%s ]*$", "%1")
     return result
 end
 
-local function __TS__StringTrimEnd(self)
+function __TS__StringTrimEnd(self)
     local result = string.gsub(self, "[%s ]*$", "")
     return result
 end
 
-local function __TS__StringTrimStart(self)
+function __TS__StringTrimStart(self)
     local result = string.gsub(self, "^[%s ]*", "")
     return result
 end
 
-local __TS__SymbolRegistryFor, __TS__SymbolRegistryKeyFor
-do
-    local symbolRegistry = {}
-    function __TS__SymbolRegistryFor(key)
-        if not symbolRegistry[key] then
-            symbolRegistry[key] = __TS__Symbol(key)
-        end
-        return symbolRegistry[key]
+____symbolRegistry = {}
+function __TS__SymbolRegistryFor(key)
+    if not ____symbolRegistry[key] then
+        ____symbolRegistry[key] = __TS__Symbol(key)
     end
-    function __TS__SymbolRegistryKeyFor(sym)
-        for key in pairs(symbolRegistry) do
-            if symbolRegistry[key] == sym then
-                return key
-            end
+    return ____symbolRegistry[key]
+end
+function __TS__SymbolRegistryKeyFor(sym)
+    for key in pairs(____symbolRegistry) do
+        if ____symbolRegistry[key] == sym then
+            return key
         end
     end
 end
 
-local function __TS__TypeOf(value)
+function __TS__TypeOf(value)
     local luaType = type(value)
     if luaType == "table" then
         return "object"
@@ -2276,197 +2339,3 @@ local function __TS__TypeOf(value)
     end
 end
 
-local WeakMap
-do
-    WeakMap = __TS__Class()
-    WeakMap.name = "WeakMap"
-    function WeakMap.prototype.____constructor(self, entries)
-        self[Symbol.toStringTag] = "WeakMap"
-        self.items = {}
-        setmetatable(self.items, {__mode = "k"})
-        if entries == nil then
-            return
-        end
-        local iterable = entries
-        if iterable[Symbol.iterator] then
-            local iterator = iterable[Symbol.iterator](iterable)
-            while true do
-                local result = iterator:next()
-                if result.done then
-                    break
-                end
-                local value = result.value
-                self.items[value[1]] = value[2]
-            end
-        else
-            for ____, kvp in ipairs(entries) do
-                self.items[kvp[1]] = kvp[2]
-            end
-        end
-    end
-    function WeakMap.prototype.delete(self, key)
-        local contains = self:has(key)
-        self.items[key] = nil
-        return contains
-    end
-    function WeakMap.prototype.get(self, key)
-        return self.items[key]
-    end
-    function WeakMap.prototype.has(self, key)
-        return self.items[key] ~= nil
-    end
-    function WeakMap.prototype.set(self, key, value)
-        self.items[key] = value
-        return self
-    end
-    WeakMap[Symbol.species] = WeakMap
-end
-
-local WeakSet
-do
-    WeakSet = __TS__Class()
-    WeakSet.name = "WeakSet"
-    function WeakSet.prototype.____constructor(self, values)
-        self[Symbol.toStringTag] = "WeakSet"
-        self.items = {}
-        setmetatable(self.items, {__mode = "k"})
-        if values == nil then
-            return
-        end
-        local iterable = values
-        if iterable[Symbol.iterator] then
-            local iterator = iterable[Symbol.iterator](iterable)
-            while true do
-                local result = iterator:next()
-                if result.done then
-                    break
-                end
-                self.items[result.value] = true
-            end
-        else
-            for ____, value in ipairs(values) do
-                self.items[value] = true
-            end
-        end
-    end
-    function WeakSet.prototype.add(self, value)
-        self.items[value] = true
-        return self
-    end
-    function WeakSet.prototype.delete(self, value)
-        local contains = self:has(value)
-        self.items[value] = nil
-        return contains
-    end
-    function WeakSet.prototype.has(self, value)
-        return self.items[value] == true
-    end
-    WeakSet[Symbol.species] = WeakSet
-end
-
-
-return {
-    __TS__ArrayConcat = __TS__ArrayConcat,
-    __TS__ArrayEntries = __TS__ArrayEntries,
-    __TS__ArrayEvery = __TS__ArrayEvery,
-    __TS__ArrayFilter = __TS__ArrayFilter,
-    __TS__ArrayFind = __TS__ArrayFind,
-    __TS__ArrayFindIndex = __TS__ArrayFindIndex,
-    __TS__ArrayFlat = __TS__ArrayFlat,
-    __TS__ArrayFlatMap = __TS__ArrayFlatMap,
-    __TS__ArrayForEach = __TS__ArrayForEach,
-    __TS__ArrayIncludes = __TS__ArrayIncludes,
-    __TS__ArrayIndexOf = __TS__ArrayIndexOf,
-    __TS__ArrayIsArray = __TS__ArrayIsArray,
-    __TS__ArrayJoin = __TS__ArrayJoin,
-    __TS__ArrayMap = __TS__ArrayMap,
-    __TS__ArrayPush = __TS__ArrayPush,
-    __TS__ArrayReduce = __TS__ArrayReduce,
-    __TS__ArrayReduceRight = __TS__ArrayReduceRight,
-    __TS__ArrayReverse = __TS__ArrayReverse,
-    __TS__ArraySetLength = __TS__ArraySetLength,
-    __TS__ArrayShift = __TS__ArrayShift,
-    __TS__ArraySlice = __TS__ArraySlice,
-    __TS__ArraySome = __TS__ArraySome,
-    __TS__ArraySort = __TS__ArraySort,
-    __TS__ArraySplice = __TS__ArraySplice,
-    __TS__ArrayToObject = __TS__ArrayToObject,
-    __TS__ArrayUnshift = __TS__ArrayUnshift,
-    __TS__Promise = __TS__Promise,
-    __TS__AsyncAwaiter = __TS__AsyncAwaiter,
-    __TS__Await = __TS__Await,
-    __TS__Class = __TS__Class,
-    __TS__ClassExtends = __TS__ClassExtends,
-    __TS__CloneDescriptor = __TS__CloneDescriptor,
-    __TS__ObjectGetOwnPropertyDescriptor = __TS__ObjectGetOwnPropertyDescriptor,
-    __TS__SetDescriptor = __TS__SetDescriptor,
-    __TS__Decorate = __TS__Decorate,
-    __TS__DecorateParam = __TS__DecorateParam,
-    __TS__DelegatedYield = __TS__DelegatedYield,
-    __TS__ObjectGetOwnPropertyDescriptors = __TS__ObjectGetOwnPropertyDescriptors,
-    __TS__Delete = __TS__Delete,
-    Error = Error,
-    RangeError = RangeError,
-    ReferenceError = ReferenceError,
-    SyntaxError = SyntaxError,
-    TypeError = TypeError,
-    URIError = URIError,
-    __TS__FunctionBind = __TS__FunctionBind,
-    __TS__Generator = __TS__Generator,
-    __TS__InstanceOf = __TS__InstanceOf,
-    __TS__InstanceOfObject = __TS__InstanceOfObject,
-    __TS__Iterator = __TS__Iterator,
-    Map = Map,
-    __TS__MathAtan2 = __TS__MathAtan2,
-    __TS__MathSign = __TS__MathSign,
-    __TS__New = __TS__New,
-    __TS__Number = __TS__Number,
-    __TS__NumberIsFinite = __TS__NumberIsFinite,
-    __TS__NumberIsNaN = __TS__NumberIsNaN,
-    __TS__NumberToString = __TS__NumberToString,
-    __TS__ObjectAssign = __TS__ObjectAssign,
-    __TS__ObjectDefineProperty = __TS__ObjectDefineProperty,
-    __TS__ObjectEntries = __TS__ObjectEntries,
-    __TS__ObjectFromEntries = __TS__ObjectFromEntries,
-    __TS__ObjectKeys = __TS__ObjectKeys,
-    __TS__ObjectRest = __TS__ObjectRest,
-    __TS__ObjectValues = __TS__ObjectValues,
-    __TS__ParseFloat = __TS__ParseFloat,
-    __TS__ParseInt = __TS__ParseInt,
-    __TS__PromiseAll = __TS__PromiseAll,
-    __TS__PromiseAllSettled = __TS__PromiseAllSettled,
-    __TS__PromiseAny = __TS__PromiseAny,
-    __TS__PromiseRace = __TS__PromiseRace,
-    Set = Set,
-    __TS__SourceMapTraceBack = __TS__SourceMapTraceBack,
-    __TS__SparseArrayNew = __TS__SparseArrayNew,
-    __TS__SparseArrayPush = __TS__SparseArrayPush,
-    __TS__SparseArraySpread = __TS__SparseArraySpread,
-    __TS__Spread = __TS__Spread,
-    __TS__StringAccess = __TS__StringAccess,
-    __TS__StringCharAt = __TS__StringCharAt,
-    __TS__StringCharCodeAt = __TS__StringCharCodeAt,
-    __TS__StringConcat = __TS__StringConcat,
-    __TS__StringEndsWith = __TS__StringEndsWith,
-    __TS__StringIncludes = __TS__StringIncludes,
-    __TS__StringPadEnd = __TS__StringPadEnd,
-    __TS__StringPadStart = __TS__StringPadStart,
-    __TS__StringReplace = __TS__StringReplace,
-    __TS__StringReplaceAll = __TS__StringReplaceAll,
-    __TS__StringSlice = __TS__StringSlice,
-    __TS__StringSplit = __TS__StringSplit,
-    __TS__StringStartsWith = __TS__StringStartsWith,
-    __TS__StringSubstr = __TS__StringSubstr,
-    __TS__StringSubstring = __TS__StringSubstring,
-    __TS__StringTrim = __TS__StringTrim,
-    __TS__StringTrimEnd = __TS__StringTrimEnd,
-    __TS__StringTrimStart = __TS__StringTrimStart,
-    __TS__Symbol = __TS__Symbol,
-    Symbol = Symbol,
-    __TS__SymbolRegistryFor = __TS__SymbolRegistryFor,
-    __TS__SymbolRegistryKeyFor = __TS__SymbolRegistryKeyFor,
-    __TS__TypeOf = __TS__TypeOf,
-    __TS__Unpack = __TS__Unpack,
-    WeakMap = WeakMap,
-    WeakSet = WeakSet
-}