typescript-to-lua 1.0.1 → 1.3.0

package/dist/lualib/lualib_bundle.lua

@@ -1,5 +1,5 @@
 function __TS__ArrayIsArray(value)
-    return (type(value) == "table") and ((value[1] ~= nil) or (next(value, nil) == nil))
+    return type(value) == "table" and (value[1] ~= nil or next(value, nil) == nil)
 end
 
 function __TS__ArrayConcat(arr1, ...)
@@ -199,7 +199,13 @@ function __TS__ArrayReduce(arr, callbackFn, ...)
         error("Reduce of empty array with no initial value", 0)
     end
     for i = k, len - 1 do
-        accumulator = callbackFn(_G, accumulator, arr[i + 1], i, arr)
+        accumulator = callbackFn(
+            _G,
+            accumulator,
+            arr[i + 1],
+            i,
+            arr
+        )
     end
     return accumulator
 end
@@ -217,7 +223,13 @@ function __TS__ArrayReduceRight(arr, callbackFn, ...)
         error("Reduce of empty array with no initial value", 0)
     end
     for i = k, 0, -1 do
-        accumulator = callbackFn(_G, accumulator, arr[i + 1], i, arr)
+        accumulator = callbackFn(
+            _G,
+            accumulator,
+            arr[i + 1],
+            i,
+            arr
+        )
     end
     return accumulator
 end
@@ -342,7 +354,7 @@ function __TS__ArraySplice(list, ...)
     if itemCount < actualDeleteCount then
         do
             local k = actualStart
-            while k < (len - actualDeleteCount) do
+            while k < len - actualDeleteCount do
                 local from = k + actualDeleteCount
                 local to = k + itemCount
                 if list[from + 1] then
@@ -355,7 +367,7 @@ function __TS__ArraySplice(list, ...)
         end
         do
             local k = len
-            while k > ((len - actualDeleteCount) + itemCount) do
+            while k > len - actualDeleteCount + itemCount do
                 list[k] = nil
                 k = k - 1
             end
@@ -364,8 +376,8 @@ function __TS__ArraySplice(list, ...)
         do
             local k = len - actualDeleteCount
             while k > actualStart do
-                local from = (k + actualDeleteCount) - 1
-                local to = (k + itemCount) - 1
+                local from = k + actualDeleteCount - 1
+                local to = k + itemCount - 1
                 if list[from + 1] then
                     list[to + 1] = list[from + 1]
                 else
@@ -382,7 +394,7 @@ function __TS__ArraySplice(list, ...)
     end
     do
         local k = #list - 1
-        while k >= ((len - actualDeleteCount) + itemCount) do
+        while k >= len - actualDeleteCount + itemCount do
             list[k + 1] = nil
             k = k - 1
         end
@@ -408,7 +420,7 @@ function __TS__ArrayFlat(array, depth)
     end
     local result = {}
     for ____, value in ipairs(array) do
-        if (depth > 0) and __TS__ArrayIsArray(value) then
+        if depth > 0 and __TS__ArrayIsArray(value) then
             result = __TS__ArrayConcat(
                 result,
                 __TS__ArrayFlat(value, depth - 1)
@@ -426,7 +438,7 @@ function __TS__ArrayFlatMap(array, callback)
         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
+            if type(value) == "table" and __TS__ArrayIsArray(value) then
                 result = __TS__ArrayConcat(result, value)
             else
                 result[#result + 1] = value
@@ -438,7 +450,7 @@ function __TS__ArrayFlatMap(array, callback)
 end
 
 function __TS__ArraySetLength(arr, length)
-    if (((length < 0) or (length ~= length)) or (length == math.huge)) or (math.floor(length) ~= length) then
+    if length < 0 or length ~= length or length == math.huge or math.floor(length) ~= length then
         error(
             "invalid array length: " .. tostring(length),
             0
@@ -454,11 +466,9 @@ function __TS__ArraySetLength(arr, length)
     return length
 end
 
-____symbolMetatable = {
-    __tostring = function(self)
-        return ("Symbol(" .. (self.description or "")) .. ")"
-    end
-}
+____symbolMetatable = {__tostring = function(self)
+    return ("Symbol(" .. (self.description or "")) .. ")"
+end}
 function __TS__Symbol(description)
     return setmetatable({description = description}, ____symbolMetatable)
 end
@@ -474,7 +484,7 @@ function __TS__InstanceOf(obj, classTbl)
         error("Right-hand side of 'instanceof' is not an object", 0)
     end
     if classTbl[Symbol.hasInstance] ~= nil then
-        return not (not classTbl[Symbol.hasInstance](classTbl, obj))
+        return not not classTbl[Symbol.hasInstance](classTbl, obj)
     end
     if type(obj) == "table" then
         local luaClass = obj.constructor
@@ -494,55 +504,276 @@ function __TS__New(target, ...)
     return instance
 end
 
+function __TS__Class(self)
+    local c = {prototype = {}}
+    c.prototype.__index = c.prototype
+    c.prototype.constructor = c
+    return c
+end
+
+__TS__Unpack = table.unpack or unpack
+
+function __TS__FunctionBind(fn, thisArg, ...)
+    local boundArgs = {...}
+    return function(____, ...)
+        local args = {...}
+        do
+            local i = 0
+            while i < #boundArgs do
+                table.insert(args, i + 1, boundArgs[i + 1])
+                i = i + 1
+            end
+        end
+        return fn(
+            thisArg,
+            __TS__Unpack(args)
+        )
+    end
+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
+    )
+    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
+    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
+            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
+            internalCallback(_G, self.rejectionReason)
+        end
+    end
+    if isFulfilled then
+        resolve(_G, self.value)
+    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
+    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
+    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
+        for ____, callback in ipairs(self.finallyCallbacks) do
+            callback(_G)
+        end
+    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
+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
+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
+            data["then"](data, resolve, reject)
+        end
+    else
+        resolve(_G, data)
+    end
+end
+
 function __TS__AsyncAwaiter(generator)
     return __TS__New(
         __TS__Promise,
         function(____, resolve, reject)
-            local asyncCoroutine, adopt, fulfilled, step
+            local adopt, fulfilled, rejected, step, asyncCoroutine
             function adopt(self, value)
-                return ((__TS__InstanceOf(value, __TS__Promise) and (function() return value end)) or (function() return __TS__Promise.resolve(value) end))()
+                local ____temp_0
+                if __TS__InstanceOf(value, __TS__Promise) then
+                    ____temp_0 = value
+                else
+                    ____temp_0 = __TS__Promise.resolve(value)
+                end
+                return ____temp_0
             end
             function fulfilled(self, value)
-                local success, resultOrError = coroutine.resume(asyncCoroutine, value)
+                local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine, value)
                 if success then
-                    step(_G, resultOrError)
+                    step(_G, resultOrError, errorOrErrorHandler)
+                else
+                    reject(_G, errorOrErrorHandler)
+                end
+            end
+            function rejected(self, handler)
+                if handler then
+                    return function(____, value)
+                        local success, hasReturnedOrError, returnedValue = pcall(handler, value)
+                        if success then
+                            if hasReturnedOrError then
+                                resolve(_G, returnedValue)
+                            else
+                                step(_G, hasReturnedOrError, handler)
+                            end
+                        else
+                            reject(_G, hasReturnedOrError)
+                        end
+                    end
                 else
-                    reject(_G, resultOrError)
+                    return function(____, value)
+                        reject(_G, value)
+                    end
                 end
             end
-            function step(self, result)
+            function step(self, result, errorHandler)
                 if coroutine.status(asyncCoroutine) == "dead" then
                     resolve(_G, result)
                 else
-                    (function()
-                        local ____self = adopt(_G, result)
-                        return ____self["then"](
-                            ____self,
-                            fulfilled,
-                            function(____, reason) return reject(_G, reason) end
-                        )
-                    end)()
+                    local ____self_1 = adopt(_G, result)
+                    ____self_1["then"](
+                        ____self_1,
+                        fulfilled,
+                        rejected(_G, errorHandler)
+                    )
                 end
             end
             asyncCoroutine = coroutine.create(generator)
-            local success, resultOrError = coroutine.resume(asyncCoroutine)
+            local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine)
             if success then
-                step(_G, resultOrError)
+                step(_G, resultOrError, errorOrErrorHandler)
             else
-                reject(_G, resultOrError)
+                reject(_G, errorOrErrorHandler)
             end
         end
     )
 end
-function __TS__Await(thing)
-    return coroutine.yield(thing)
-end
-
-function __TS__Class(self)
-    local c = {prototype = {}}
-    c.prototype.__index = c.prototype
-    c.prototype.constructor = c
-    return c
+function __TS__Await(errorHandler, thing)
+    return coroutine.yield(errorHandler, thing)
 end
 
 function __TS__ClassExtends(target, base)
@@ -571,21 +802,21 @@ function __TS__ClassExtends(target, base)
 end
 
 function __TS__CloneDescriptor(____bindingPattern0)
+    local value
+    local writable
+    local set
+    local get
+    local configurable
     local enumerable
     enumerable = ____bindingPattern0.enumerable
-    local configurable
     configurable = ____bindingPattern0.configurable
-    local get
     get = ____bindingPattern0.get
-    local set
     set = ____bindingPattern0.set
-    local writable
     writable = ____bindingPattern0.writable
-    local value
     value = ____bindingPattern0.value
     local descriptor = {enumerable = enumerable == true, configurable = configurable == true}
-    local hasGetterOrSetter = (get ~= nil) or (set ~= nil)
-    local hasValueOrWritableAttribute = (writable ~= nil) or (value ~= nil)
+    local hasGetterOrSetter = get ~= nil or set ~= nil
+    local hasValueOrWritableAttribute = writable ~= nil or value ~= nil
     if hasGetterOrSetter and hasValueOrWritableAttribute then
         error("Invalid property descriptor. Cannot both specify accessors and a value or writable attribute.", 0)
     end
@@ -663,7 +894,13 @@ function __TS__SetDescriptor(target, key, desc, isPrototype)
     if isPrototype == nil then
         isPrototype = false
     end
-    local metatable = ((isPrototype and (function() return target end)) or (function() return getmetatable(target) 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)
@@ -708,7 +945,7 @@ function __TS__Decorate(decorators, target, key, desc)
                     local value = rawget(target, key)
                     local descriptor = __TS__ObjectGetOwnPropertyDescriptor(target, key) or ({configurable = true, writable = true, value = value})
                     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)
+                    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)
                     else
@@ -743,28 +980,107 @@ function __TS__ObjectGetOwnPropertyDescriptors(object)
     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(
-                ((("Cannot delete property " .. tostring(key)) .. " of ") .. tostring(target)) .. ".",
+                __TS__New(
+                    TypeError,
+                    ((("Cannot delete property " .. tostring(key)) .. " of ") .. tostring(target)) .. "."
+                ),
                 0
             )
         end
         descriptors[key] = nil
         return true
     end
-    if target[key] ~= nil then
-        target[key] = nil
-        return true
-    end
-    return false
+    target[key] = nil
+    return true
 end
 
 function __TS__StringAccess(self, index)
-    if (index >= 0) and (index < #self) then
+    if index >= 0 and index < #self then
         return string.sub(self, index + 1, index + 1)
     end
 end
@@ -772,9 +1088,7 @@ end
 function __TS__DelegatedYield(iterable)
     if type(iterable) == "string" then
         for index = 0, #iterable - 1 do
-            coroutine.yield(
-                __TS__StringAccess(iterable, index)
-            )
+            coroutine.yield(__TS__StringAccess(iterable, index))
         end
     elseif iterable.____coroutine ~= nil then
         local co = iterable.____coroutine
@@ -806,102 +1120,6 @@ function __TS__DelegatedYield(iterable)
     end
 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
-Error = __TS__InitErrorClass(
-    _G,
-    (function()
-        local ____ = __TS__Class()
-        ____.name = ""
-        function ____.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 ____.prototype.__tostring(self)
-            return (((self.message ~= "") and (function() return (self.name .. ": ") .. self.message end)) or (function() return self.name end))()
-        end
-        return ____
-    end)(),
-    "Error"
-)
-for ____, errorName in ipairs({"RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"}) do
-    _G[errorName] = __TS__InitErrorClass(
-        _G,
-        (function()
-            local ____ = __TS__Class()
-            ____.name = ____.name
-            __TS__ClassExtends(____, Error)
-            function ____.prototype.____constructor(self, ...)
-                Error.prototype.____constructor(self, ...)
-                self.name = errorName
-            end
-            return ____
-        end)(),
-        errorName
-    )
-end
-
-__TS__Unpack = table.unpack or unpack
-
-function __TS__FunctionBind(fn, thisArg, ...)
-    local boundArgs = {...}
-    return function(____, ...)
-        local args = {...}
-        do
-            local i = 0
-            while i < #boundArgs do
-                table.insert(args, i + 1, boundArgs[i + 1])
-                i = i + 1
-            end
-        end
-        return fn(
-            thisArg,
-            __TS__Unpack(args)
-        )
-    end
-end
-
 function __TS__GeneratorIterator(self)
     return self
 end
@@ -924,11 +1142,7 @@ function __TS__Generator(fn)
         local args = {...}
         local argsLength = select("#", ...)
         return {
-            ____coroutine = coroutine.create(
-                function() return fn(
-                    (unpack or table.unpack)(args, 1, argsLength)
-                ) end
-            ),
+            ____coroutine = coroutine.create(function() return fn((unpack or table.unpack)(args, 1, argsLength)) end),
             [Symbol.iterator] = __TS__GeneratorIterator,
             next = __TS__GeneratorNext
         }
@@ -937,7 +1151,7 @@ end
 
 function __TS__InstanceOfObject(value)
     local valueType = type(value)
-    return (valueType == "table") or (valueType == "function")
+    return valueType == "table" or valueType == "function"
 end
 
 function __TS__IteratorGeneratorStep(self)
@@ -978,150 +1192,146 @@ function __TS__Iterator(iterable)
     end
 end
 
-Map = (function()
-    local 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])
-            end
-        end
+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 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
+    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
-            self.nextKey[key] = nil
-            self.previousKey[key] = nil
+            local value = result.value
+            self:set(value[1], value[2])
         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)
+    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.nextKey[key] = nil
+        self.previousKey[key] = nil
     end
-    function Map.prototype.get(self, key)
-        return self.items[key]
+    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.has(self, key)
-        return (self.nextKey[key] ~= nil) or (self.lastKey == 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.set(self, key, value)
-        local isNewValue = not self:has(key)
-        if isNewValue then
-            self.size = self.size + 1
+    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
+    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 ____ = self
-        local items = ____.items
-        local nextKey = ____.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 ____ = self
-        local items = ____.items
-        local nextKey = ____.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
-    return Map
-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
+Map = Map
 
 __TS__MathAtan2 = math.atan2 or math.atan
 
@@ -1146,14 +1356,14 @@ function __TS__Number(value)
         end
         return 0 / 0
     elseif valueType == "boolean" then
-        return (value and 1) or 0
+        return value and 1 or 0
     else
         return 0 / 0
     end
 end
 
 function __TS__NumberIsFinite(value)
-    return (((type(value) == "number") and (value == value)) and (value ~= math.huge)) and (value ~= -math.huge)
+    return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
 end
 
 function __TS__NumberIsNaN(value)
@@ -1162,16 +1372,14 @@ end
 
 ____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
+    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
+    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 integer, fraction = math.modf(math.abs(self))
     local result = ""
     if radix == 8 then
         result = string.format("%o", integer)
@@ -1205,9 +1413,15 @@ function __TS__NumberToString(self, radix)
 end
 
 function __TS__ObjectDefineProperty(target, key, desc)
-    local luaKey = (((type(key) == "number") and (function() return key + 1 end)) or (function() return key end))()
+    local ____temp_0
+    if type(key) == "number" then
+        ____temp_0 = key + 1
+    else
+        ____temp_0 = key
+    end
+    local luaKey = ____temp_0
     local value = rawget(target, luaKey)
-    local hasGetterOrSetter = (desc.get ~= nil) or (desc.set ~= nil)
+    local hasGetterOrSetter = desc.get ~= nil or desc.set ~= nil
     local descriptor
     if hasGetterOrSetter then
         if value ~= nil then
@@ -1219,13 +1433,39 @@ function __TS__ObjectDefineProperty(target, key, desc)
         descriptor = desc
     else
         local valueExists = value ~= nil
+        local ____desc_set_5 = desc.set
+        local ____desc_get_6 = desc.get
+        local ____temp_1
+        if desc.configurable ~= nil then
+            ____temp_1 = desc.configurable
+        else
+            ____temp_1 = valueExists
+        end
+        local ____temp_2
+        if desc.enumerable ~= nil then
+            ____temp_2 = desc.enumerable
+        else
+            ____temp_2 = valueExists
+        end
+        local ____temp_3
+        if desc.writable ~= nil then
+            ____temp_3 = desc.writable
+        else
+            ____temp_3 = valueExists
+        end
+        local ____temp_4
+        if desc.value ~= nil then
+            ____temp_4 = desc.value
+        else
+            ____temp_4 = value
+        end
         descriptor = {
-            set = desc.set,
-            get = desc.get,
-            configurable = (((desc.configurable ~= nil) and (function() return desc.configurable end)) or (function() return valueExists end))(),
-            enumerable = (((desc.enumerable ~= nil) and (function() return desc.enumerable end)) or (function() return valueExists end))(),
-            writable = (((desc.writable ~= nil) and (function() return desc.writable end)) or (function() return valueExists end))(),
-            value = (((desc.value ~= nil) and (function() return desc.value end)) or (function() return value end))()
+            set = ____desc_set_5,
+            get = ____desc_get_6,
+            configurable = ____temp_1,
+            enumerable = ____temp_2,
+            writable = ____temp_3,
+            value = ____temp_4
         }
     end
     __TS__SetDescriptor(target, luaKey, descriptor)
@@ -1287,41 +1527,19 @@ function __TS__ObjectValues(obj)
     return result
 end
 
-function __TS__OptionalChainAccess(____table, key)
-    if ____table then
-        return ____table[key]
-    end
-    return nil
-end
-
-function __TS__OptionalFunctionCall(f, ...)
-    if f then
-        return f(...)
-    end
-    return nil
-end
-
-function __TS__OptionalMethodCall(____table, methodName, isMethodOptional, ...)
-    if ____table then
-        local method = ____table[methodName]
-        if method then
-            return method(____table, ...)
-        elseif not isMethodOptional then
-            error(methodName .. " is not a function", 0)
-        end
-    end
-    return nil
-end
-
 function __TS__ParseFloat(numberString)
     local infinityMatch = string.match(numberString, "^%s*(-?Infinity)")
     if infinityMatch then
-        return (((__TS__StringAccess(infinityMatch, 0) == "-") and (function() return -math.huge end)) or (function() return math.huge end))()
+        local ____temp_0
+        if __TS__StringAccess(infinityMatch, 0) == "-" then
+            ____temp_0 = -math.huge
+        else
+            ____temp_0 = math.huge
+        end
+        return ____temp_0
     end
-    local number = tonumber(
-        string.match(numberString, "^%s*(-?%d+%.?%d*)")
-    )
-    return number or (0 / 0)
+    local number = tonumber(string.match(numberString, "^%s*(-?%d+%.?%d*)"))
+    return number or 0 / 0
 end
 
 function __TS__StringSubstr(self, from, length)
@@ -1329,7 +1547,7 @@ function __TS__StringSubstr(self, from, length)
         from = 0
     end
     if length ~= nil then
-        if (length ~= length) or (length <= 0) then
+        if length ~= length or length <= 0 then
             return ""
         end
         length = length + from
@@ -1344,7 +1562,7 @@ function __TS__StringSubstring(self, start, ____end)
     if ____end ~= ____end then
         ____end = 0
     end
-    if (____end ~= nil) and (start > ____end) then
+    if ____end ~= nil and start > ____end then
         start, ____end = ____end, start
     end
     if start >= 0 then
@@ -1352,7 +1570,7 @@ function __TS__StringSubstring(self, start, ____end)
     else
         start = 1
     end
-    if (____end ~= nil) and (____end < 0) then
+    if ____end ~= nil and ____end < 0 then
         ____end = 0
     end
     return string.sub(self, start, ____end)
@@ -1365,13 +1583,25 @@ function __TS__ParseInt(numberString, base)
         local hexMatch = string.match(numberString, "^%s*-?0[xX]")
         if hexMatch then
             base = 16
-            numberString = ((string.match(hexMatch, "-") and (function() return "-" .. __TS__StringSubstr(numberString, #hexMatch) end)) or (function() return __TS__StringSubstr(numberString, #hexMatch) end))()
+            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
     end
-    if (base < 2) or (base > 36) then
+    if base < 2 or base > 36 then
         return 0 / 0
     end
-    local allowedDigits = (((base <= 10) and (function() return __TS__StringSubstring(__TS__parseInt_base_pattern, 0, base) end)) or (function() return __TS__StringSubstr(__TS__parseInt_base_pattern, 0, 10 + (2 * (base - 10))) 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),
@@ -1387,165 +1617,6 @@ function __TS__ParseInt(numberString, base)
     end
 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
-    )
-    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 ____try, e = pcall(
-            function()
-                executor(
-                    _G,
-                    __TS__FunctionBind(self.resolve, self),
-                    __TS__FunctionBind(self.reject, self)
-                )
-            end
-        )
-        if not ____try then
-            self:reject(e)
-        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(_G)
-    local promise = ____.promise
-    local resolve = ____.resolve
-    local reject = ____.reject
-    if onFulfilled then
-        local internalCallback = self:createPromiseResolvingCallback(onFulfilled, resolve, reject)
-        __TS__ArrayPush(self.fulfilledCallbacks, internalCallback)
-        if self.state == __TS__PromiseState.Fulfilled then
-            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 self.state == __TS__PromiseState.Rejected then
-            internalCallback(_G, self.rejectionReason)
-        end
-    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
-    end
-    return self
-end
-function __TS__Promise.prototype.resolve(self, data)
-    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
-        for ____, callback in ipairs(self.finallyCallbacks) do
-            callback(_G)
-        end
-    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
-end
-function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
-    return function(____, value)
-        do
-            local ____try, e = pcall(
-                function()
-                    self:handleCallbackData(
-                        f(_G, value),
-                        resolve,
-                        reject
-                    )
-                end
-            )
-            if not ____try then
-                reject(_G, e)
-            end
-        end
-    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
-            data["then"](data, resolve, reject)
-        end
-    else
-        resolve(_G, data)
-    end
-end
-
 function __TS__PromiseAll(iterable)
     local results = {}
     local toResolve = {}
@@ -1711,226 +1782,239 @@ function __TS__PromiseRace(iterable)
     )
 end
 
-Set = (function()
-    local 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
+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
-    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
+    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.nextKey[value] = nil
-            self.previousKey[value] = nil
+            self:add(result.value)
         end
-        return contains
-    end
-    function Set.prototype.forEach(self, callback)
-        for ____, key in __TS__Iterator(
-            self:keys()
-        ) do
-            callback(_G, key, key, self)
+    else
+        local array = values
+        for ____, value in ipairs(array) do
+            self:add(value)
         end
     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
-        }
-    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.add(self, value)
+    local isNewValue = not self:has(value)
+    if isNewValue then
+        self.size = self.size + 1
     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
-        }
+    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
-    Set[Symbol.species] = Set
-    return Set
-end)()
-
-WeakMap = (function()
-    local 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
+    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
-            for ____, kvp in ipairs(entries) do
-                self.items[kvp[1]] = kvp[2]
-            end
+            self.firstKey = nil
+            self.lastKey = nil
         end
+        self.nextKey[value] = nil
+        self.previousKey[value] = nil
     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]
+    return contains
+end
+function Set.prototype.forEach(self, callback)
+    for ____, key in __TS__Iterator(self:keys()) do
+        callback(_G, key, key, self)
     end
-    function WeakMap.prototype.has(self, key)
-        return self.items[key] ~= 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
+    }
+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 WeakMap.prototype.set(self, key, value)
-        self.items[key] = value
-        return self
+    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
-    WeakMap[Symbol.species] = WeakMap
-    return WeakMap
-end)()
-
-WeakSet = (function()
-    local 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
+    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 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 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 WeakSet.prototype.has(self, value)
-        return self.items[value] == true
+    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
-    WeakSet[Symbol.species] = WeakSet
-    return WeakSet
-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
+WeakSet = WeakSet
 
 function __TS__SourceMapTraceBack(fileName, sourceMap)
     _G.__TS__sourcemap = _G.__TS__sourcemap or ({})
@@ -1939,7 +2023,7 @@ function __TS__SourceMapTraceBack(fileName, sourceMap)
         _G.__TS__originalTraceback = debug.traceback
         debug.traceback = function(thread, message, level)
             local trace
-            if ((thread == nil) and (message == nil)) and (level == nil) then
+            if thread == nil and message == nil and level == nil then
                 trace = _G.__TS__originalTraceback()
             else
                 trace = _G.__TS__originalTraceback(thread, message, level)
@@ -1947,16 +2031,26 @@ function __TS__SourceMapTraceBack(fileName, sourceMap)
             if type(trace) ~= "string" then
                 return trace
             end
-            local result = string.gsub(
-                trace,
-                "(%S+).lua:(%d+)",
-                function(file, line)
-                    local fileSourceMap = _G.__TS__sourcemap[file .. ".lua"]
-                    if fileSourceMap and fileSourceMap[line] then
-                        return (file .. ".ts:") .. tostring(fileSourceMap[line])
+            local function replacer(____, file, srcFile, line)
+                local fileSourceMap = _G.__TS__sourcemap[file]
+                if fileSourceMap and fileSourceMap[line] then
+                    local data = fileSourceMap[line]
+                    if type(data) == "number" then
+                        return (srcFile .. ":") .. tostring(data)
                     end
-                    return (file .. ".lua:") .. line
+                    return (tostring(data.file) .. ":") .. tostring(data.line)
                 end
+                return (file .. ":") .. line
+            end
+            local result = string.gsub(
+                trace,
+                "(%S+)%.lua:(%d+)",
+                function(file, line) return replacer(_G, file .. ".lua", file .. ".ts", line) end
+            )
+            result = string.gsub(
+                result,
+                "(%[string \"[^\"]+\"%]):(%d+)",
+                function(file, line) return replacer(_G, file, "unknown", line) end
             )
             return result
         end
@@ -1998,7 +2092,7 @@ function __TS__StringCharCodeAt(self, index)
     if index < 0 then
         return 0 / 0
     end
-    return string.byte(self, index + 1) or (0 / 0)
+    return string.byte(self, index + 1) or 0 / 0
 end
 
 function __TS__StringConcat(str1, ...)
@@ -2011,10 +2105,10 @@ function __TS__StringConcat(str1, ...)
 end
 
 function __TS__StringEndsWith(self, searchString, endPosition)
-    if (endPosition == nil) or (endPosition > #self) then
+    if endPosition == nil or endPosition > #self then
         endPosition = #self
     end
-    return string.sub(self, (endPosition - #searchString) + 1, endPosition) == searchString
+    return string.sub(self, endPosition - #searchString + 1, endPosition) == searchString
 end
 
 function __TS__StringIncludes(self, searchString, position)
@@ -2034,10 +2128,10 @@ function __TS__StringPadEnd(self, maxLength, fillString)
     if maxLength ~= maxLength then
         maxLength = 0
     end
-    if (maxLength == -math.huge) or (maxLength == math.huge) then
+    if maxLength == -math.huge or maxLength == math.huge then
         error("Invalid string length", 0)
     end
-    if (#self >= maxLength) or (#fillString == 0) then
+    if #self >= maxLength or #fillString == 0 then
         return self
     end
     maxLength = maxLength - #self
@@ -2061,10 +2155,10 @@ function __TS__StringPadStart(self, maxLength, fillString)
     if maxLength ~= maxLength then
         maxLength = 0
     end
-    if (maxLength == -math.huge) or (maxLength == math.huge) then
+    if maxLength == -math.huge or maxLength == math.huge then
         error("Invalid string length", 0)
     end
-    if (#self >= maxLength) or (#fillString == 0) then
+    if #self >= maxLength or #fillString == 0 then
         return self
     end
     maxLength = maxLength - #self
@@ -2082,24 +2176,61 @@ function __TS__StringPadStart(self, maxLength, fillString)
 end
 
 function __TS__StringReplace(source, searchValue, replaceValue)
-    searchValue = string.gsub(searchValue, "[%%%(%)%.%+%-%*%?%[%^%$]", "%%%1")
+    local startPos, endPos = string.find(source, searchValue, nil, true)
+    if not startPos then
+        return source
+    end
+    local sub = string.sub
+    local before = sub(source, 1, startPos - 1)
+    local ____temp_0
     if type(replaceValue) == "string" then
-        replaceValue = string.gsub(replaceValue, "%%", "%%%%")
-        local result = string.gsub(source, searchValue, replaceValue, 1)
-        return result
+        ____temp_0 = replaceValue
     else
-        local result = string.gsub(
-            source,
-            searchValue,
-            function(match) return replaceValue(_G, match) end,
-            1
-        )
-        return result
+        ____temp_0 = replaceValue(_G, searchValue, startPos - 1, source)
+    end
+    local replacement = ____temp_0
+    local after = sub(source, endPos + 1)
+    return (before .. replacement) .. after
+end
+
+function __TS__StringReplaceAll(source, searchValue, replaceValue)
+    local replacer
+    if type(replaceValue) == "string" then
+        replacer = function() return replaceValue end
+    else
+        replacer = replaceValue
+    end
+    local parts = {}
+    local partsIndex = 1
+    local sub = string.sub
+    if #searchValue == 0 then
+        parts[1] = replacer(_G, "", 0, source)
+        partsIndex = 2
+        for i = 1, #source do
+            parts[partsIndex] = sub(source, i, i)
+            parts[partsIndex + 1] = replacer(_G, "", i, source)
+            partsIndex = partsIndex + 2
+        end
+    else
+        local find = string.find
+        local currentPos = 1
+        while true do
+            local startPos, endPos = find(source, searchValue, currentPos, true)
+            if not startPos then
+                break
+            end
+            parts[partsIndex] = sub(source, currentPos, startPos - 1)
+            parts[partsIndex + 1] = replacer(_G, searchValue, startPos - 1, source)
+            partsIndex = partsIndex + 2
+            currentPos = endPos + 1
+        end
+        parts[partsIndex] = sub(source, currentPos)
     end
+    return table.concat(parts)
 end
 
 function __TS__StringSlice(self, start, ____end)
-    if (start == nil) or (start ~= start) then
+    if start == nil or start ~= start then
         start = 0
     end
     if ____end ~= ____end then
@@ -2108,7 +2239,7 @@ function __TS__StringSlice(self, start, ____end)
     if start >= 0 then
         start = start + 1
     end
-    if (____end ~= nil) and (____end < 0) then
+    if ____end ~= nil and ____end < 0 then
         ____end = ____end - 1
     end
     return string.sub(self, start, ____end)
@@ -2124,8 +2255,8 @@ function __TS__StringSplit(source, separator, limit)
     local out = {}
     local index = 0
     local count = 0
-    if (separator == nil) or (separator == "") then
-        while (index < (#source - 1)) and (count < limit) do
+    if separator == nil or separator == "" then
+        while index < #source - 1 and count < limit do
             out[count + 1] = __TS__StringAccess(source, index)
             count = count + 1
             index = index + 1
@@ -2133,7 +2264,7 @@ function __TS__StringSplit(source, separator, limit)
     else
         local separatorLength = #separator
         local nextIndex = (string.find(source, separator, nil, true) or 0) - 1
-        while (nextIndex >= 0) and (count < limit) do
+        while nextIndex >= 0 and count < limit do
             out[count + 1] = __TS__StringSubstring(source, index, nextIndex)
             count = count + 1
             index = nextIndex + separatorLength
@@ -2152,7 +2283,7 @@ function __TS__StringSplit(source, separator, limit)
 end
 
 function __TS__StringStartsWith(self, searchString, position)
-    if (position == nil) or (position < 0) then
+    if position == nil or position < 0 then
         position = 0
     end
     return string.sub(self, position + 1, #searchString + position) == searchString