@noita-ts/pollnet 0.2.0 → 0.3.0

package/dist/lualib_bundle.lua

@@ -1,36 +1,7 @@
-local function __TS__ArrayAt(self, relativeIndex)
-    local absoluteIndex = relativeIndex < 0 and #self + relativeIndex or relativeIndex
-    if absoluteIndex >= 0 and absoluteIndex < #self then
-        return self[absoluteIndex + 1]
-    end
-    return nil
-end
-
-local function __TS__ArrayIsArray(value)
-    return type(value) == "table" and (value[1] ~= nil or next(value) == nil)
-end
-
-local function __TS__ArrayConcat(self, ...)
-    local items = {...}
-    local result = {}
-    local len = 0
-    for i = 1, #self do
-        len = len + 1
-        result[len] = self[i]
-    end
-    for i = 1, #items do
-        local item = items[i]
-        if __TS__ArrayIsArray(item) then
-            for j = 1, #item do
-                len = len + 1
-                result[len] = item[j]
-            end
-        else
-            len = len + 1
-            result[len] = item
-        end
-    end
-    return result
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
 end
 
 local __TS__Symbol, Symbol
@@ -51,555 +22,6 @@ do
     }
 end
 
-local function __TS__ArrayEntries(array)
-    local key = 0
-    return {
-        [Symbol.iterator] = function(self)
-            return self
-        end,
-        next = function(self)
-            local result = {done = array[key + 1] == nil, value = {key, array[key + 1]}}
-            key = key + 1
-            return result
-        end
-    }
-end
-
-local function __TS__ArrayEvery(self, callbackfn, thisArg)
-    for i = 1, #self do
-        if not callbackfn(thisArg, self[i], i - 1, self) then
-            return false
-        end
-    end
-    return true
-end
-
-local function __TS__ArrayFill(self, value, start, ____end)
-    local relativeStart = start or 0
-    local relativeEnd = ____end or #self
-    if relativeStart < 0 then
-        relativeStart = relativeStart + #self
-    end
-    if relativeEnd < 0 then
-        relativeEnd = relativeEnd + #self
-    end
-    do
-        local i = relativeStart
-        while i < relativeEnd do
-            self[i + 1] = value
-            i = i + 1
-        end
-    end
-    return self
-end
-
-local function __TS__ArrayFilter(self, callbackfn, thisArg)
-    local result = {}
-    local len = 0
-    for i = 1, #self do
-        if callbackfn(thisArg, self[i], i - 1, self) then
-            len = len + 1
-            result[len] = self[i]
-        end
-    end
-    return result
-end
-
-local function __TS__ArrayForEach(self, callbackFn, thisArg)
-    for i = 1, #self do
-        callbackFn(thisArg, self[i], i - 1, self)
-    end
-end
-
-local function __TS__ArrayFind(self, predicate, thisArg)
-    for i = 1, #self do
-        local elem = self[i]
-        if predicate(thisArg, elem, i - 1, self) then
-            return elem
-        end
-    end
-    return nil
-end
-
-local function __TS__ArrayFindIndex(self, callbackFn, thisArg)
-    for i = 1, #self do
-        if callbackFn(thisArg, self[i], i - 1, self) then
-            return i - 1
-        end
-    end
-    return -1
-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)
-    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 __TS__ArrayFrom
-do
-    local function arrayLikeStep(self, index)
-        index = index + 1
-        if index > self.length then
-            return
-        end
-        return index, self[index]
-    end
-    local function arrayLikeIterator(arr)
-        if type(arr.length) == "number" then
-            return arrayLikeStep, arr, 0
-        end
-        return __TS__Iterator(arr)
-    end
-    function __TS__ArrayFrom(arrayLike, mapFn, thisArg)
-        local result = {}
-        if mapFn == nil then
-            for ____, v in arrayLikeIterator(arrayLike) do
-                result[#result + 1] = v
-            end
-        else
-            local i = 0
-            for ____, v in arrayLikeIterator(arrayLike) do
-                local ____mapFn_3 = mapFn
-                local ____thisArg_1 = thisArg
-                local ____v_2 = v
-                local ____i_0 = i
-                i = ____i_0 + 1
-                result[#result + 1] = ____mapFn_3(____thisArg_1, ____v_2, ____i_0)
-            end
-        end
-        return result
-    end
-end
-
-local function __TS__ArrayIncludes(self, searchElement, fromIndex)
-    if fromIndex == nil then
-        fromIndex = 0
-    end
-    local len = #self
-    local k = fromIndex
-    if fromIndex < 0 then
-        k = len + fromIndex
-    end
-    if k < 0 then
-        k = 0
-    end
-    for i = k + 1, len do
-        if self[i] == searchElement then
-            return true
-        end
-    end
-    return false
-end
-
-local function __TS__ArrayIndexOf(self, searchElement, fromIndex)
-    if fromIndex == nil then
-        fromIndex = 0
-    end
-    local len = #self
-    if len == 0 then
-        return -1
-    end
-    if fromIndex >= len then
-        return -1
-    end
-    if fromIndex < 0 then
-        fromIndex = len + fromIndex
-        if fromIndex < 0 then
-            fromIndex = 0
-        end
-    end
-    for i = fromIndex + 1, len do
-        if self[i] == searchElement then
-            return i - 1
-        end
-    end
-    return -1
-end
-
-local function __TS__ArrayJoin(self, separator)
-    if separator == nil then
-        separator = ","
-    end
-    local parts = {}
-    for i = 1, #self do
-        parts[i] = tostring(self[i])
-    end
-    return table.concat(parts, separator)
-end
-
-local function __TS__ArrayMap(self, callbackfn, thisArg)
-    local result = {}
-    for i = 1, #self do
-        result[i] = callbackfn(thisArg, self[i], i - 1, self)
-    end
-    return result
-end
-
-local function __TS__ArrayPush(self, ...)
-    local items = {...}
-    local len = #self
-    for i = 1, #items do
-        len = len + 1
-        self[len] = items[i]
-    end
-    return len
-end
-
-local function __TS__ArrayPushArray(self, items)
-    local len = #self
-    for i = 1, #items do
-        len = len + 1
-        self[len] = items[i]
-    end
-    return len
-end
-
-local function __TS__CountVarargs(...)
-    return select("#", ...)
-end
-
-local function __TS__ArrayReduce(self, callbackFn, ...)
-    local len = #self
-    local k = 0
-    local accumulator = nil
-    if __TS__CountVarargs(...) ~= 0 then
-        accumulator = ...
-    elseif len > 0 then
-        accumulator = self[1]
-        k = 1
-    else
-        error("Reduce of empty array with no initial value", 0)
-    end
-    for i = k + 1, len do
-        accumulator = callbackFn(
-            nil,
-            accumulator,
-            self[i],
-            i - 1,
-            self
-        )
-    end
-    return accumulator
-end
-
-local function __TS__ArrayReduceRight(self, callbackFn, ...)
-    local len = #self
-    local k = len - 1
-    local accumulator = nil
-    if __TS__CountVarargs(...) ~= 0 then
-        accumulator = ...
-    elseif len > 0 then
-        accumulator = self[k + 1]
-        k = k - 1
-    else
-        error("Reduce of empty array with no initial value", 0)
-    end
-    for i = k + 1, 1, -1 do
-        accumulator = callbackFn(
-            nil,
-            accumulator,
-            self[i],
-            i - 1,
-            self
-        )
-    end
-    return accumulator
-end
-
-local function __TS__ArrayReverse(self)
-    local i = 1
-    local j = #self
-    while i < j do
-        local temp = self[j]
-        self[j] = self[i]
-        self[i] = temp
-        i = i + 1
-        j = j - 1
-    end
-    return self
-end
-
-local function __TS__ArrayUnshift(self, ...)
-    local items = {...}
-    local numItemsToInsert = #items
-    if numItemsToInsert == 0 then
-        return #self
-    end
-    for i = #self, 1, -1 do
-        self[i + numItemsToInsert] = self[i]
-    end
-    for i = 1, numItemsToInsert do
-        self[i] = items[i]
-    end
-    return #self
-end
-
-local function __TS__ArraySort(self, compareFn)
-    if compareFn ~= nil then
-        table.sort(
-            self,
-            function(a, b) return compareFn(nil, a, b) < 0 end
-        )
-    else
-        table.sort(self)
-    end
-    return self
-end
-
-local function __TS__ArraySlice(self, first, last)
-    local len = #self
-    first = first or 0
-    if first < 0 then
-        first = len + first
-        if first < 0 then
-            first = 0
-        end
-    else
-        if first > len then
-            first = len
-        end
-    end
-    last = last or len
-    if last < 0 then
-        last = len + last
-        if last < 0 then
-            last = 0
-        end
-    else
-        if last > len then
-            last = len
-        end
-    end
-    local out = {}
-    first = first + 1
-    last = last + 1
-    local n = 1
-    while first < last do
-        out[n] = self[first]
-        first = first + 1
-        n = n + 1
-    end
-    return out
-end
-
-local function __TS__ArraySome(self, callbackfn, thisArg)
-    for i = 1, #self do
-        if callbackfn(thisArg, self[i], i - 1, self) then
-            return true
-        end
-    end
-    return false
-end
-
-local function __TS__ArraySplice(self, ...)
-    local args = {...}
-    local len = #self
-    local actualArgumentCount = __TS__CountVarargs(...)
-    local start = args[1]
-    local deleteCount = args[2]
-    if start < 0 then
-        start = len + start
-        if start < 0 then
-            start = 0
-        end
-    elseif start > len then
-        start = len
-    end
-    local itemCount = actualArgumentCount - 2
-    if itemCount < 0 then
-        itemCount = 0
-    end
-    local actualDeleteCount
-    if actualArgumentCount == 0 then
-        actualDeleteCount = 0
-    elseif actualArgumentCount == 1 then
-        actualDeleteCount = len - start
-    else
-        actualDeleteCount = deleteCount or 0
-        if actualDeleteCount < 0 then
-            actualDeleteCount = 0
-        end
-        if actualDeleteCount > len - start then
-            actualDeleteCount = len - start
-        end
-    end
-    local out = {}
-    for k = 1, actualDeleteCount do
-        local from = start + k
-        if self[from] ~= nil then
-            out[k] = self[from]
-        end
-    end
-    if itemCount < actualDeleteCount then
-        for k = start + 1, len - actualDeleteCount do
-            local from = k + actualDeleteCount
-            local to = k + itemCount
-            if self[from] then
-                self[to] = self[from]
-            else
-                self[to] = nil
-            end
-        end
-        for k = len - actualDeleteCount + itemCount + 1, len do
-            self[k] = nil
-        end
-    elseif itemCount > actualDeleteCount then
-        for k = len - actualDeleteCount, start + 1, -1 do
-            local from = k + actualDeleteCount
-            local to = k + itemCount
-            if self[from] then
-                self[to] = self[from]
-            else
-                self[to] = nil
-            end
-        end
-    end
-    local j = start + 1
-    for i = 3, actualArgumentCount do
-        self[j] = args[i]
-        j = j + 1
-    end
-    for k = #self, len - actualDeleteCount + itemCount + 1, -1 do
-        self[k] = nil
-    end
-    return out
-end
-
-local function __TS__ArrayToObject(self)
-    local object = {}
-    for i = 1, #self do
-        object[i - 1] = self[i]
-    end
-    return object
-end
-
-local function __TS__ArrayFlat(self, depth)
-    if depth == nil then
-        depth = 1
-    end
-    local result = {}
-    local len = 0
-    for i = 1, #self do
-        local value = self[i]
-        if depth > 0 and __TS__ArrayIsArray(value) then
-            local toAdd
-            if depth == 1 then
-                toAdd = value
-            else
-                toAdd = __TS__ArrayFlat(value, depth - 1)
-            end
-            for j = 1, #toAdd do
-                local val = toAdd[j]
-                len = len + 1
-                result[len] = val
-            end
-        else
-            len = len + 1
-            result[len] = value
-        end
-    end
-    return result
-end
-
-local function __TS__ArrayFlatMap(self, callback, thisArg)
-    local result = {}
-    local len = 0
-    for i = 1, #self do
-        local value = callback(thisArg, self[i], i - 1, self)
-        if __TS__ArrayIsArray(value) then
-            for j = 1, #value do
-                len = len + 1
-                result[len] = value[j]
-            end
-        else
-            len = len + 1
-            result[len] = value
-        end
-    end
-    return result
-end
-
-local function __TS__ArraySetLength(self, 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
-    for i = length + 1, #self do
-        self[i] = nil
-    end
-    return length
-end
-
-local __TS__Unpack = table.unpack or unpack
-
-local function __TS__ArrayToReversed(self)
-    local copy = {__TS__Unpack(self)}
-    __TS__ArrayReverse(copy)
-    return copy
-end
-
-local function __TS__ArrayToSorted(self, compareFn)
-    local copy = {__TS__Unpack(self)}
-    __TS__ArraySort(copy, compareFn)
-    return copy
-end
-
-local function __TS__ArrayToSpliced(self, start, deleteCount, ...)
-    local copy = {__TS__Unpack(self)}
-    __TS__ArraySplice(copy, start, deleteCount, ...)
-    return copy
-end
-
-local function __TS__ArrayWith(self, index, value)
-    local copy = {__TS__Unpack(self)}
-    copy[index + 1] = value
-    return copy
-end
-
-local function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(...)
-    return instance
-end
-
 local function __TS__InstanceOf(obj, classTbl)
     if type(classTbl) ~= "table" then
         error("Right-hand side of 'instanceof' is not an object", 0)
@@ -791,65 +213,66 @@ do
     end
 end
 
-local __TS__AsyncAwaiter, __TS__Await
+local __TS__StringSplit
 do
-    local ____coroutine = _G.coroutine or ({})
-    local cocreate = ____coroutine.create
-    local coresume = ____coroutine.resume
-    local costatus = ____coroutine.status
-    local coyield = ____coroutine.yield
-    function __TS__AsyncAwaiter(generator)
-        return __TS__New(
-            __TS__Promise,
-            function(____, resolve, reject)
-                local fulfilled, step, resolved, asyncCoroutine
-                function fulfilled(self, value)
-                    local success, resultOrError = coresume(asyncCoroutine, value)
-                    if success then
-                        return step(resultOrError)
-                    end
-                    return reject(nil, resultOrError)
-                end
-                function step(result)
-                    if resolved then
-                        return
-                    end
-                    if costatus(asyncCoroutine) == "dead" then
-                        return resolve(nil, result)
-                    end
-                    return __TS__Promise.resolve(result):addCallbacks(fulfilled, reject)
-                end
-                resolved = false
-                asyncCoroutine = cocreate(generator)
-                local success, resultOrError = coresume(
-                    asyncCoroutine,
-                    function(____, v)
-                        resolved = true
-                        return __TS__Promise.resolve(v):addCallbacks(resolve, reject)
-                    end
-                )
-                if success then
-                    return step(resultOrError)
-                else
-                    return reject(nil, resultOrError)
+    local sub = string.sub
+    local find = string.find
+    function __TS__StringSplit(source, separator, limit)
+        if limit == nil then
+            limit = 4294967295
+        end
+        if limit == 0 then
+            return {}
+        end
+        local result = {}
+        local resultIndex = 1
+        if separator == nil or separator == "" then
+            for i = 1, #source do
+                result[resultIndex] = sub(source, i, i)
+                resultIndex = resultIndex + 1
+            end
+        else
+            local currentPos = 1
+            while resultIndex <= limit do
+                local startPos, endPos = find(source, separator, currentPos, true)
+                if not startPos then
+                    break
                 end
+                result[resultIndex] = sub(source, currentPos, startPos - 1)
+                resultIndex = resultIndex + 1
+                currentPos = endPos + 1
             end
-        )
-    end
-    function __TS__Await(thing)
-        return coyield(thing)
+            if resultIndex <= limit then
+                result[resultIndex] = sub(source, currentPos)
+            end
+        end
+        return result
     end
 end
 
-local function __TS__ClassExtends(target, base)
-    target.____super = base
-    local staticMetatable = setmetatable({__index = base}, base)
-    setmetatable(target, staticMetatable)
-    local baseMetatable = getmetatable(base)
-    if baseMetatable then
-        if type(baseMetatable.__index) == "function" then
-            staticMetatable.__index = baseMetatable.__index
-        end
+local function __TS__ArrayIsArray(value)
+    return type(value) == "table" and (value[1] ~= nil or next(value) == nil)
+end
+
+local function __TS__StringIncludes(self, searchString, position)
+    if not position then
+        position = 1
+    else
+        position = position + 1
+    end
+    local index = string.find(self, searchString, position, true)
+    return index ~= nil
+end
+
+local function __TS__ClassExtends(target, base)
+    target.____super = base
+    local staticMetatable = setmetatable({__index = base}, base)
+    setmetatable(target, staticMetatable)
+    local baseMetatable = getmetatable(base)
+    if baseMetatable then
+        if type(baseMetatable.__index) == "function" then
+            staticMetatable.__index = baseMetatable.__index
+        end
         if type(baseMetatable.__newindex) == "function" then
             staticMetatable.__newindex = baseMetatable.__newindex
         end
@@ -866,238 +289,6 @@ local function __TS__ClassExtends(target, base)
     end
 end
 
-local function __TS__CloneDescriptor(____bindingPattern0)
-    local value
-    local writable
-    local set
-    local get
-    local configurable
-    local enumerable
-    enumerable = ____bindingPattern0.enumerable
-    configurable = ____bindingPattern0.configurable
-    get = ____bindingPattern0.get
-    set = ____bindingPattern0.set
-    writable = ____bindingPattern0.writable
-    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
-    if hasGetterOrSetter and hasValueOrWritableAttribute then
-        error("Invalid property descriptor. Cannot both specify accessors and a value or writable attribute.", 0)
-    end
-    if get or set then
-        descriptor.get = get
-        descriptor.set = set
-    else
-        descriptor.value = value
-        descriptor.writable = writable == true
-    end
-    return descriptor
-end
-
-local function __TS__Decorate(self, originalValue, decorators, context)
-    local result = originalValue
-    do
-        local i = #decorators
-        while i >= 0 do
-            local decorator = decorators[i + 1]
-            if decorator ~= nil then
-                local ____decorator_result_0 = decorator(self, result, context)
-                if ____decorator_result_0 == nil then
-                    ____decorator_result_0 = result
-                end
-                result = ____decorator_result_0
-            end
-            i = i - 1
-        end
-    end
-    return result
-end
-
-local function __TS__ObjectAssign(target, ...)
-    local sources = {...}
-    for i = 1, #sources do
-        local source = sources[i]
-        if type(source) == "table" then
-            for key in pairs(source) do
-                target[key] = source[key]
-            end
-        end
-    end
-    return target
-end
-
-local function __TS__ObjectGetOwnPropertyDescriptor(object, key)
-    local metatable = getmetatable(object)
-    if not metatable then
-        return
-    end
-    if not rawget(metatable, "_descriptors") then
-        return
-    end
-    return rawget(metatable, "_descriptors")[key]
-end
-
-local __TS__DescriptorGet
-do
-    local getmetatable = _G.getmetatable
-    local ____rawget = _G.rawget
-    function __TS__DescriptorGet(self, metatable, key)
-        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 ~= nil then
-                    if descriptor.get then
-                        return descriptor.get(self)
-                    end
-                    return descriptor.value
-                end
-            end
-            metatable = getmetatable(metatable)
-        end
-    end
-end
-
-local __TS__DescriptorSet
-do
-    local getmetatable = _G.getmetatable
-    local ____rawget = _G.rawget
-    local rawset = _G.rawset
-    function __TS__DescriptorSet(self, metatable, key, value)
-        while metatable do
-            local descriptors = ____rawget(metatable, "_descriptors")
-            if descriptors then
-                local descriptor = descriptors[key]
-                if descriptor ~= nil 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
-                    return
-                end
-            end
-            metatable = getmetatable(metatable)
-        end
-        rawset(self, key, value)
-    end
-end
-
-local __TS__SetDescriptor
-do
-    local getmetatable = _G.getmetatable
-    local function descriptorIndex(self, key)
-        return __TS__DescriptorGet(
-            self,
-            getmetatable(self),
-            key
-        )
-    end
-    local function descriptorNewIndex(self, key, value)
-        return __TS__DescriptorSet(
-            self,
-            getmetatable(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
-        if not isPrototype and not rawget(metatable, "_isOwnDescriptorMetatable") then
-            local instanceMetatable = {}
-            instanceMetatable._isOwnDescriptorMetatable = true
-            setmetatable(instanceMetatable, metatable)
-            setmetatable(target, instanceMetatable)
-            metatable = instanceMetatable
-        end
-        local value = rawget(target, key)
-        if value ~= nil then
-            rawset(target, key, nil)
-        end
-        if not rawget(metatable, "_descriptors") then
-            metatable._descriptors = {}
-        end
-        metatable._descriptors[key] = __TS__CloneDescriptor(desc)
-        metatable.__index = descriptorIndex
-        metatable.__newindex = descriptorNewIndex
-    end
-end
-
-local function __TS__DecorateLegacy(decorators, target, key, desc)
-    local result = target
-    do
-        local i = #decorators
-        while i >= 0 do
-            local decorator = decorators[i + 1]
-            if decorator ~= nil then
-                local oldResult = result
-                if key == nil then
-                    result = decorator(nil, 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 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
-                        __TS__SetDescriptor(
-                            target,
-                            key,
-                            __TS__ObjectAssign({}, descriptor, desc)
-                        )
-                    end
-                elseif desc == false then
-                    result = decorator(nil, target, key, desc)
-                else
-                    result = decorator(nil, target, key)
-                end
-                result = result or oldResult
-            end
-            i = i - 1
-        end
-    end
-    return result
-end
-
-local function __TS__DecorateParam(paramIndex, decorator)
-    return function(____, target, key) return decorator(nil, target, key, paramIndex) end
-end
-
-local function __TS__StringIncludes(self, searchString, position)
-    if not position then
-        position = 1
-    else
-        position = position + 1
-    end
-    local index = string.find(self, searchString, position, true)
-    return index ~= nil
-end
-
 local Error, RangeError, ReferenceError, SyntaxError, TypeError, URIError
 do
     local function getErrorStack(self, constructor)
@@ -1183,1622 +374,16 @@ do
     URIError = createErrorClass(nil, "URIError")
 end
 
-local function __TS__ObjectGetOwnPropertyDescriptors(object)
-    local metatable = getmetatable(object)
-    if not metatable then
-        return {}
-    end
-    return rawget(metatable, "_descriptors") or ({})
-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
-end
-
-local 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)
-    if type(iterable) == "string" then
-        for index = 0, #iterable - 1 do
-            coroutine.yield(__TS__StringAccess(iterable, index))
-        end
-    elseif iterable.____coroutine ~= nil then
-        local co = iterable.____coroutine
-        while true do
-            local status, value = coroutine.resume(co)
-            if not status then
-                error(value, 0)
-            end
-            if coroutine.status(co) == "dead" then
-                return value
-            else
-                coroutine.yield(value)
-            end
-        end
-    elseif iterable[Symbol.iterator] then
-        local iterator = iterable[Symbol.iterator](iterable)
-        while true do
-            local result = iterator:next()
-            if result.done then
-                return result.value
-            else
-                coroutine.yield(result.value)
-            end
-        end
-    else
-        for ____, value in ipairs(iterable) do
-            coroutine.yield(value)
-        end
-    end
-end
-
-local function __TS__FunctionBind(fn, ...)
-    local boundArgs = {...}
-    return function(____, ...)
-        local args = {...}
-        __TS__ArrayUnshift(
-            args,
-            __TS__Unpack(boundArgs)
-        )
-        return fn(__TS__Unpack(args))
-    end
-end
-
-local __TS__Generator
-do
-    local function generatorIterator(self)
-        return self
-    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"
-        }
-    end
-    function __TS__Generator(fn)
-        return function(...)
-            local args = {...}
-            local argsLength = __TS__CountVarargs(...)
-            return {
-                ____coroutine = coroutine.create(function() return fn(__TS__Unpack(args, 1, argsLength)) end),
-                [Symbol.iterator] = generatorIterator,
-                next = generatorNext
-            }
-        end
-    end
-end
-
-local function __TS__InstanceOfObject(value)
-    local valueType = type(value)
-    return valueType == "table" or valueType == "function"
-end
-
-local function __TS__LuaIteratorSpread(self, state, firstKey)
-    local results = {}
-    local key, value = self(state, firstKey)
-    while key do
-        results[#results + 1] = {key, value}
-        key, value = self(state, key)
-    end
-    return __TS__Unpack(results)
-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])
-            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 ~= nil and previous ~= nil then
-                self.nextKey[previous] = next
-                self.previousKey[next] = previous
-            elseif next ~= nil then
-                self.firstKey = next
-                self.previousKey[next] = nil
-            elseif previous ~= nil 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
-        self.items[key] = nil
-        return contains
-    end
-    function Map.prototype.forEach(self, callback)
-        for ____, key in __TS__Iterator(self:keys()) do
-            callback(nil, self.items[key], key, self)
-        end
-    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
-        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 function getFirstKey()
-            return self.firstKey
-        end
-        local items = self.items
-        local nextKey = self.nextKey
-        local key
-        local started = false
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                if not started then
-                    started = true
-                    key = getFirstKey(nil)
-                else
-                    key = nextKey[key]
-                end
-                return {done = not key, value = {key, items[key]}}
-            end
-        }
-    end
-    function Map.prototype.keys(self)
-        local function getFirstKey()
-            return self.firstKey
-        end
-        local nextKey = self.nextKey
-        local key
-        local started = false
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                if not started then
-                    started = true
-                    key = getFirstKey(nil)
-                else
-                    key = nextKey[key]
-                end
-                return {done = not key, value = key}
-            end
-        }
-    end
-    function Map.prototype.values(self)
-        local function getFirstKey()
-            return self.firstKey
-        end
-        local items = self.items
-        local nextKey = self.nextKey
-        local key
-        local started = false
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                if not started then
-                    started = true
-                    key = getFirstKey(nil)
-                else
-                    key = nextKey[key]
-                end
-                return {done = not key, value = items[key]}
-            end
-        }
-    end
-    Map[Symbol.species] = Map
-end
-
-local function __TS__MapGroupBy(items, keySelector)
-    local result = __TS__New(Map)
-    local i = 0
-    for ____, item in __TS__Iterator(items) do
-        local key = keySelector(nil, item, i)
-        if result:has(key) then
-            local ____temp_0 = result:get(key)
-            ____temp_0[#____temp_0 + 1] = item
-        else
-            result:set(key, {item})
-        end
-        i = i + 1
-    end
-    return result
-end
-
-local __TS__Match = string.match
-
-local __TS__MathAtan2 = math.atan2 or math.atan
-
-local __TS__MathModf = math.modf
-
-local function __TS__NumberIsNaN(value)
-    return value ~= value
-end
-
-local function __TS__MathSign(val)
-    if __TS__NumberIsNaN(val) or val == 0 then
-        return val
-    end
-    if val < 0 then
-        return -1
-    end
-    return 1
-end
-
-local function __TS__NumberIsFinite(value)
-    return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
-end
-
-local function __TS__MathTrunc(val)
-    if not __TS__NumberIsFinite(val) or val == 0 then
-        return val
-    end
-    return val > 0 and math.floor(val) or math.ceil(val)
-end
-
-local function __TS__Number(value)
-    local valueType = type(value)
-    if valueType == "number" then
-        return value
-    elseif valueType == "string" then
-        local numberValue = tonumber(value)
-        if numberValue then
-            return numberValue
-        end
-        if value == "Infinity" then
-            return math.huge
-        end
-        if value == "-Infinity" then
-            return -math.huge
-        end
-        local stringWithoutSpaces = string.gsub(value, "%s", "")
-        if stringWithoutSpaces == "" then
-            return 0
-        end
-        return 0 / 0
-    elseif valueType == "boolean" then
-        return value and 1 or 0
-    else
-        return 0 / 0
-    end
-end
-
-local function __TS__NumberIsInteger(value)
-    return __TS__NumberIsFinite(value) and math.floor(value) == value
-end
-
-local function __TS__StringSubstring(self, start, ____end)
-    if ____end ~= ____end then
-        ____end = 0
-    end
-    if ____end ~= nil and start > ____end then
-        start, ____end = ____end, start
-    end
-    if start >= 0 then
-        start = start + 1
-    else
-        start = 1
-    end
-    if ____end ~= nil and ____end < 0 then
-        ____end = 0
-    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 = __TS__Match(numberString, "^%s*-?0[xX]")
-            if hexMatch ~= nil then
-                base = 16
-                numberString = (__TS__Match(hexMatch, "-")) and "-" .. __TS__StringSubstring(numberString, #hexMatch) or __TS__StringSubstring(numberString, #hexMatch)
-            end
-        end
-        if base < 2 or base > 36 then
-            return 0 / 0
-        end
-        local allowedDigits = base <= 10 and __TS__StringSubstring(parseIntBasePattern, 0, base) or __TS__StringSubstring(parseIntBasePattern, 0, 10 + 2 * (base - 10))
-        local pattern = ("^%s*(-?[" .. allowedDigits) .. "]*)"
-        local number = tonumber((__TS__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
-end
-
-local function __TS__ParseFloat(numberString)
-    local infinityMatch = __TS__Match(numberString, "^%s*(-?Infinity)")
-    if infinityMatch ~= nil then
-        return __TS__StringAccess(infinityMatch, 0) == "-" and -math.huge or math.huge
-    end
-    local number = tonumber((__TS__Match(numberString, "^%s*(-?%d+%.?%d*)")))
-    return number or 0 / 0
-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 = __TS__MathModf(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
-end
-
-local function __TS__NumberToFixed(self, fractionDigits)
-    if math.abs(self) >= 1e+21 or self ~= self then
-        return tostring(self)
-    end
-    local f = math.floor(fractionDigits or 0)
-    if f < 0 or f > 99 then
-        error("toFixed() digits argument must be between 0 and 99", 0)
-    end
-    return string.format(
-        ("%." .. tostring(f)) .. "f",
-        self
-    )
-end
-
-local function __TS__ObjectDefineProperty(target, key, desc)
-    local luaKey = type(key) == "number" and key + 1 or key
-    local value = rawget(target, luaKey)
-    local hasGetterOrSetter = desc.get ~= nil or desc.set ~= nil
-    local descriptor
-    if hasGetterOrSetter then
-        if value ~= nil then
-            error(
-                "Cannot redefine property: " .. tostring(key),
-                0
-            )
-        end
-        descriptor = desc
-    else
-        local valueExists = value ~= nil
-        local ____desc_set_4 = desc.set
-        local ____desc_get_5 = desc.get
-        local ____desc_configurable_0 = desc.configurable
-        if ____desc_configurable_0 == nil then
-            ____desc_configurable_0 = valueExists
-        end
-        local ____desc_enumerable_1 = desc.enumerable
-        if ____desc_enumerable_1 == nil then
-            ____desc_enumerable_1 = valueExists
-        end
-        local ____desc_writable_2 = desc.writable
-        if ____desc_writable_2 == nil then
-            ____desc_writable_2 = valueExists
-        end
-        local ____temp_3
-        if desc.value ~= nil then
-            ____temp_3 = desc.value
-        else
-            ____temp_3 = value
-        end
-        descriptor = {
-            set = ____desc_set_4,
-            get = ____desc_get_5,
-            configurable = ____desc_configurable_0,
-            enumerable = ____desc_enumerable_1,
-            writable = ____desc_writable_2,
-            value = ____temp_3
-        }
-    end
-    __TS__SetDescriptor(target, luaKey, descriptor)
-    return target
-end
-
-local function __TS__ObjectEntries(obj)
-    local result = {}
-    local len = 0
-    for key in pairs(obj) do
-        len = len + 1
-        result[len] = {key, obj[key]}
-    end
-    return result
-end
-
-local function __TS__ObjectFromEntries(entries)
-    local obj = {}
-    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
-            obj[value[1]] = value[2]
-        end
-    else
-        for ____, entry in ipairs(entries) do
-            obj[entry[1]] = entry[2]
-        end
-    end
-    return obj
-end
-
-local function __TS__ObjectGroupBy(items, keySelector)
-    local result = {}
-    local i = 0
-    for ____, item in __TS__Iterator(items) do
-        local key = keySelector(nil, item, i)
-        if result[key] ~= nil then
-            local ____result_key_0 = result[key]
-            ____result_key_0[#____result_key_0 + 1] = item
-        else
-            result[key] = {item}
-        end
-        i = i + 1
-    end
-    return result
-end
-
-local function __TS__ObjectKeys(obj)
-    local result = {}
-    local len = 0
-    for key in pairs(obj) do
-        len = len + 1
-        result[len] = key
-    end
-    return result
-end
-
-local function __TS__ObjectRest(target, usedProperties)
-    local result = {}
-    for property in pairs(target) do
-        if not usedProperties[property] then
-            result[property] = target[property]
-        end
-    end
-    return result
-end
-
-local function __TS__ObjectValues(obj)
-    local result = {}
-    local len = 0
-    for key in pairs(obj) do
-        len = len + 1
-        result[len] = obj[key]
-    end
-    return result
-end
-
-local 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
-                results[i + 1] = item.value
-            elseif item.state == 2 then
-                return __TS__Promise.reject(item.rejectionReason)
-            else
-                numToResolve = numToResolve + 1
-                toResolve[i] = item
-            end
-        else
-            results[i + 1] = item
-        end
-        i = i + 1
-    end
-    if numToResolve == 0 then
-        return __TS__Promise.resolve(results)
-    end
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve, reject)
-            for index, promise in pairs(toResolve) do
-                promise["then"](
-                    promise,
-                    function(____, data)
-                        results[index + 1] = data
-                        numToResolve = numToResolve - 1
-                        if numToResolve == 0 then
-                            resolve(nil, results)
-                        end
-                    end,
-                    function(____, reason)
-                        reject(nil, reason)
-                    end
-                )
-            end
-        end
-    )
-end
-
-local 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
-                results[i + 1] = {status = "fulfilled", value = item.value}
-            elseif item.state == 2 then
-                results[i + 1] = {status = "rejected", reason = item.rejectionReason}
-            else
-                numToResolve = numToResolve + 1
-                toResolve[i] = item
-            end
-        else
-            results[i + 1] = {status = "fulfilled", value = item}
-        end
-        i = i + 1
-    end
-    if numToResolve == 0 then
-        return __TS__Promise.resolve(results)
-    end
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve)
-            for index, promise in pairs(toResolve) do
-                promise["then"](
-                    promise,
-                    function(____, data)
-                        results[index + 1] = {status = "fulfilled", value = data}
-                        numToResolve = numToResolve - 1
-                        if numToResolve == 0 then
-                            resolve(nil, results)
-                        end
-                    end,
-                    function(____, reason)
-                        results[index + 1] = {status = "rejected", reason = reason}
-                        numToResolve = numToResolve - 1
-                        if numToResolve == 0 then
-                            resolve(nil, results)
-                        end
-                    end
-                )
-            end
-        end
-    )
-end
-
-local 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
-                return __TS__Promise.resolve(item.value)
-            elseif item.state == 2 then
-                rejections[#rejections + 1] = item.rejectionReason
-            else
-                pending[#pending + 1] = item
-            end
-        else
-            return __TS__Promise.resolve(item)
-        end
-    end
-    if #pending == 0 then
-        return __TS__Promise.reject("No promises to resolve with .any()")
-    end
-    local numResolved = 0
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve, reject)
-            for ____, promise in ipairs(pending) do
-                promise["then"](
-                    promise,
-                    function(____, data)
-                        resolve(nil, data)
-                    end,
-                    function(____, reason)
-                        rejections[#rejections + 1] = reason
-                        numResolved = numResolved + 1
-                        if numResolved == #pending then
-                            reject(nil, {name = "AggregateError", message = "All Promises rejected", errors = rejections})
-                        end
-                    end
-                )
-            end
-        end
-    )
-end
-
-local 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
-                return __TS__Promise.resolve(item.value)
-            elseif item.state == 2 then
-                return __TS__Promise.reject(item.rejectionReason)
-            else
-                pending[#pending + 1] = item
-            end
-        else
-            return __TS__Promise.resolve(item)
-        end
-    end
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve, reject)
-            for ____, promise in ipairs(pending) do
-                promise["then"](
-                    promise,
-                    function(____, value) return resolve(nil, value) end,
-                    function(____, reason) return reject(nil, 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)
-            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 ~= nil and previous ~= nil then
-                self.nextKey[previous] = next
-                self.previousKey[next] = previous
-            elseif next ~= nil then
-                self.firstKey = next
-                self.previousKey[next] = nil
-            elseif previous ~= nil 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
-        return contains
-    end
-    function Set.prototype.forEach(self, callback)
-        for ____, key in __TS__Iterator(self:keys()) do
-            callback(nil, key, key, self)
-        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 function getFirstKey()
-            return self.firstKey
-        end
-        local nextKey = self.nextKey
-        local key
-        local started = false
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                if not started then
-                    started = true
-                    key = getFirstKey(nil)
-                else
-                    key = nextKey[key]
-                end
-                return {done = not key, value = {key, key}}
-            end
-        }
-    end
-    function Set.prototype.keys(self)
-        local function getFirstKey()
-            return self.firstKey
-        end
-        local nextKey = self.nextKey
-        local key
-        local started = false
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                if not started then
-                    started = true
-                    key = getFirstKey(nil)
-                else
-                    key = nextKey[key]
-                end
-                return {done = not key, value = key}
-            end
-        }
-    end
-    function Set.prototype.values(self)
-        local function getFirstKey()
-            return self.firstKey
-        end
-        local nextKey = self.nextKey
-        local key
-        local started = false
-        return {
-            [Symbol.iterator] = function(self)
-                return self
-            end,
-            next = function(self)
-                if not started then
-                    started = true
-                    key = getFirstKey(nil)
-                else
-                    key = nextKey[key]
-                end
-                return {done = not key, value = key}
-            end
-        }
-    end
-    function Set.prototype.union(self, other)
-        local result = __TS__New(Set, self)
-        for ____, item in __TS__Iterator(other) do
-            result:add(item)
-        end
-        return result
-    end
-    function Set.prototype.intersection(self, other)
-        local result = __TS__New(Set)
-        for ____, item in __TS__Iterator(self) do
-            if other:has(item) then
-                result:add(item)
-            end
-        end
-        return result
-    end
-    function Set.prototype.difference(self, other)
-        local result = __TS__New(Set, self)
-        for ____, item in __TS__Iterator(other) do
-            result:delete(item)
-        end
-        return result
-    end
-    function Set.prototype.symmetricDifference(self, other)
-        local result = __TS__New(Set, self)
-        for ____, item in __TS__Iterator(other) do
-            if self:has(item) then
-                result:delete(item)
-            else
-                result:add(item)
-            end
-        end
-        return result
-    end
-    function Set.prototype.isSubsetOf(self, other)
-        for ____, item in __TS__Iterator(self) do
-            if not other:has(item) then
-                return false
-            end
-        end
-        return true
-    end
-    function Set.prototype.isSupersetOf(self, other)
-        for ____, item in __TS__Iterator(other) do
-            if not self:has(item) then
-                return false
-            end
-        end
-        return true
-    end
-    function Set.prototype.isDisjointFrom(self, other)
-        for ____, item in __TS__Iterator(self) do
-            if other:has(item) then
-                return false
-            end
-        end
-        return true
-    end
-    Set[Symbol.species] = Set
-end
-
-local function __TS__SparseArrayNew(...)
-    local sparseArray = {...}
-    sparseArray.sparseLength = __TS__CountVarargs(...)
-    return sparseArray
-end
-
-local function __TS__SparseArrayPush(sparseArray, ...)
-    local args = {...}
-    local argsLen = __TS__CountVarargs(...)
-    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 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
-
-local 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
-        debug.traceback = function(thread, message, level)
-            local trace
-            if thread == nil and message == nil and level == nil then
-                trace = originalTraceback()
-            elseif __TS__StringIncludes(_VERSION, "Lua 5.0") then
-                trace = originalTraceback((("[Level " .. tostring(level)) .. "] ") .. tostring(message))
-            else
-                trace = originalTraceback(thread, message, level)
-            end
-            if type(trace) ~= "string" then
-                return trace
-            end
-            local function replacer(____, file, srcFile, line)
-                local fileSourceMap = _G.__TS__sourcemap[file]
-                if fileSourceMap ~= nil and fileSourceMap[line] ~= nil then
-                    local data = fileSourceMap[line]
-                    if type(data) == "number" then
-                        return (srcFile .. ":") .. tostring(data)
-                    end
-                    return (data.file .. ":") .. tostring(data.line)
-                end
-                return (file .. ":") .. line
-            end
-            local result = string.gsub(
-                trace,
-                "([^%s<]+)%.lua:(%d+)",
-                function(file, line) return replacer(nil, file .. ".lua", file .. ".ts", line) end
-            )
-            local function stringReplacer(____, file, line)
-                local fileSourceMap = _G.__TS__sourcemap[file]
-                if fileSourceMap ~= nil and fileSourceMap[line] ~= nil then
-                    local chunkName = (__TS__Match(file, "%[string \"([^\"]+)\"%]"))
-                    local sourceName = string.gsub(chunkName, ".lua$", ".ts")
-                    local data = fileSourceMap[line]
-                    if type(data) == "number" then
-                        return (sourceName .. ":") .. tostring(data)
-                    end
-                    return (data.file .. ":") .. tostring(data.line)
-                end
-                return (file .. ":") .. line
-            end
-            result = string.gsub(
-                result,
-                "(%[string \"[^\"]+\"%]):(%d+)",
-                function(file, line) return stringReplacer(nil, file, line) end
-            )
-            return result
-        end
-    end
-end
-
-local function __TS__Spread(iterable)
-    local arr = {}
-    if type(iterable) == "string" then
-        for i = 0, #iterable - 1 do
-            arr[i + 1] = __TS__StringAccess(iterable, i)
-        end
-    else
-        local len = 0
-        for ____, item in __TS__Iterator(iterable) do
-            len = len + 1
-            arr[len] = item
-        end
-    end
-    return __TS__Unpack(arr)
-end
-
-local function __TS__StringCharAt(self, pos)
-    if pos ~= pos then
-        pos = 0
-    end
-    if pos < 0 then
-        return ""
-    end
-    return string.sub(self, pos + 1, pos + 1)
-end
-
-local function __TS__StringCharCodeAt(self, index)
-    if index ~= index then
-        index = 0
-    end
-    if index < 0 then
-        return 0 / 0
-    end
-    return string.byte(self, index + 1) or 0 / 0
-end
-
-local 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__StringPadEnd(self, maxLength, fillString)
-    if fillString == nil then
-        fillString = " "
-    end
-    if maxLength ~= maxLength then
-        maxLength = 0
-    end
-    if maxLength == -math.huge or maxLength == math.huge then
-        error("Invalid string length", 0)
-    end
-    if #self >= maxLength or #fillString == 0 then
-        return self
-    end
-    maxLength = maxLength - #self
-    if maxLength > #fillString then
-        fillString = fillString .. string.rep(
-            fillString,
-            math.floor(maxLength / #fillString)
-        )
-    end
-    return self .. string.sub(
-        fillString,
-        1,
-        math.floor(maxLength)
-    )
-end
-
-local function __TS__StringPadStart(self, maxLength, fillString)
-    if fillString == nil then
-        fillString = " "
-    end
-    if maxLength ~= maxLength then
-        maxLength = 0
-    end
-    if maxLength == -math.huge or maxLength == math.huge then
-        error("Invalid string length", 0)
-    end
-    if #self >= maxLength or #fillString == 0 then
-        return self
-    end
-    maxLength = maxLength - #self
-    if maxLength > #fillString then
-        fillString = fillString .. string.rep(
-            fillString,
-            math.floor(maxLength / #fillString)
-        )
-    end
-    return string.sub(
-        fillString,
-        1,
-        math.floor(maxLength)
-    ) .. self
-end
-
-local __TS__StringReplace
-do
-    local sub = string.sub
-    function __TS__StringReplace(source, searchValue, replaceValue)
-        local startPos, endPos = string.find(source, searchValue, nil, true)
-        if not startPos then
-            return source
-        end
-        local before = sub(source, 1, startPos - 1)
-        local replacement = type(replaceValue) == "string" and replaceValue or replaceValue(nil, searchValue, startPos - 1, source)
-        local after = sub(source, endPos + 1)
-        return (before .. replacement) .. after
-    end
-end
-
-local __TS__StringSplit
-do
-    local sub = string.sub
-    local find = string.find
-    function __TS__StringSplit(source, separator, limit)
-        if limit == nil then
-            limit = 4294967295
-        end
-        if limit == 0 then
-            return {}
-        end
-        local result = {}
-        local resultIndex = 1
-        if separator == nil or separator == "" then
-            for i = 1, #source do
-                result[resultIndex] = sub(source, i, i)
-                resultIndex = resultIndex + 1
-            end
-        else
-            local currentPos = 1
-            while resultIndex <= limit do
-                local startPos, endPos = find(source, separator, currentPos, true)
-                if not startPos then
-                    break
-                end
-                result[resultIndex] = sub(source, currentPos, startPos - 1)
-                resultIndex = resultIndex + 1
-                currentPos = endPos + 1
-            end
-            if resultIndex <= limit then
-                result[resultIndex] = sub(source, currentPos)
-            end
-        end
-        return result
-    end
-end
-
-local __TS__StringReplaceAll
-do
-    local sub = string.sub
-    local find = string.find
-    function __TS__StringReplaceAll(source, searchValue, replaceValue)
-        if type(replaceValue) == "string" then
-            local concat = table.concat(
-                __TS__StringSplit(source, searchValue),
-                replaceValue
-            )
-            if #searchValue == 0 then
-                return (replaceValue .. concat) .. replaceValue
-            end
-            return concat
-        end
-        local parts = {}
-        local partsIndex = 1
-        if #searchValue == 0 then
-            parts[1] = replaceValue(nil, "", 0, source)
-            partsIndex = 2
-            for i = 1, #source do
-                parts[partsIndex] = sub(source, i, i)
-                parts[partsIndex + 1] = replaceValue(nil, "", i, source)
-                partsIndex = partsIndex + 2
-            end
-        else
-            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] = replaceValue(nil, searchValue, startPos - 1, source)
-                partsIndex = partsIndex + 2
-                currentPos = endPos + 1
-            end
-            parts[partsIndex] = sub(source, currentPos)
-        end
-        return table.concat(parts)
-    end
-end
-
-local function __TS__StringSlice(self, start, ____end)
-    if start == nil or start ~= start then
-        start = 0
-    end
-    if ____end ~= ____end then
-        ____end = 0
-    end
-    if start >= 0 then
-        start = start + 1
-    end
-    if ____end ~= nil and ____end < 0 then
-        ____end = ____end - 1
-    end
-    return string.sub(self, start, ____end)
-end
-
-local 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__StringSubstr(self, from, length)
-    if from ~= from then
-        from = 0
-    end
-    if length ~= nil then
-        if length ~= length or length <= 0 then
-            return ""
-        end
-        length = length + from
-    end
-    if from >= 0 then
-        from = from + 1
-    end
-    return string.sub(self, from, length)
-end
-
-local function __TS__StringTrim(self)
-    local result = string.gsub(self, "^[%s ]*(.-)[%s ]*$", "%1")
-    return result
-end
-
-local function __TS__StringTrimEnd(self)
-    local result = string.gsub(self, "[%s ]*$", "")
-    return result
-end
-
-local 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]
-    end
-    function __TS__SymbolRegistryKeyFor(sym)
-        for key in pairs(symbolRegistry) do
-            if symbolRegistry[key] == sym then
-                return key
-            end
-        end
-        return nil
-    end
-end
-
-local function __TS__TypeOf(value)
-    local luaType = type(value)
-    if luaType == "table" then
-        return "object"
-    elseif luaType == "nil" then
-        return "undefined"
-    else
-        return luaType
-    end
-end
-
-local function __TS__Using(self, cb, ...)
-    local args = {...}
-    local thrownError
-    local ok, result = xpcall(
-        function() return cb(__TS__Unpack(args)) end,
-        function(err)
-            thrownError = err
-            return thrownError
-        end
-    )
-    local argArray = {__TS__Unpack(args)}
-    do
-        local i = #argArray - 1
-        while i >= 0 do
-            local ____self_0 = argArray[i + 1]
-            ____self_0[Symbol.dispose](____self_0)
-            i = i - 1
-        end
-    end
-    if not ok then
-        error(thrownError, 0)
-    end
-    return result
-end
-
-local function __TS__UsingAsync(self, cb, ...)
-    local args = {...}
-    return __TS__AsyncAwaiter(function(____awaiter_resolve)
-        local thrownError
-        local ok, result = xpcall(
-            function() return cb(
-                nil,
-                __TS__Unpack(args)
-            ) end,
-            function(err)
-                thrownError = err
-                return thrownError
-            end
-        )
-        local argArray = {__TS__Unpack(args)}
-        do
-            local i = #argArray - 1
-            while i >= 0 do
-                if argArray[i + 1][Symbol.dispose] ~= nil then
-                    local ____self_0 = argArray[i + 1]
-                    ____self_0[Symbol.dispose](____self_0)
-                end
-                if argArray[i + 1][Symbol.asyncDispose] ~= nil then
-                    local ____self_1 = argArray[i + 1]
-                    __TS__Await(____self_1[Symbol.asyncDispose](____self_1))
-                end
-                i = i - 1
-            end
-        end
-        if not ok then
-            error(thrownError, 0)
-        end
-        return ____awaiter_resolve(nil, result)
-    end)
-end
-
 return {
-  __TS__ArrayAt = __TS__ArrayAt,
-  __TS__ArrayConcat = __TS__ArrayConcat,
-  __TS__ArrayEntries = __TS__ArrayEntries,
-  __TS__ArrayEvery = __TS__ArrayEvery,
-  __TS__ArrayFill = __TS__ArrayFill,
-  __TS__ArrayFilter = __TS__ArrayFilter,
-  __TS__ArrayForEach = __TS__ArrayForEach,
-  __TS__ArrayFind = __TS__ArrayFind,
-  __TS__ArrayFindIndex = __TS__ArrayFindIndex,
-  __TS__ArrayFrom = __TS__ArrayFrom,
-  __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__ArrayPushArray = __TS__ArrayPushArray,
-  __TS__ArrayReduce = __TS__ArrayReduce,
-  __TS__ArrayReduceRight = __TS__ArrayReduceRight,
-  __TS__ArrayReverse = __TS__ArrayReverse,
-  __TS__ArrayUnshift = __TS__ArrayUnshift,
-  __TS__ArraySort = __TS__ArraySort,
-  __TS__ArraySlice = __TS__ArraySlice,
-  __TS__ArraySome = __TS__ArraySome,
-  __TS__ArraySplice = __TS__ArraySplice,
-  __TS__ArrayToObject = __TS__ArrayToObject,
-  __TS__ArrayFlat = __TS__ArrayFlat,
-  __TS__ArrayFlatMap = __TS__ArrayFlatMap,
-  __TS__ArraySetLength = __TS__ArraySetLength,
-  __TS__ArrayToReversed = __TS__ArrayToReversed,
-  __TS__ArrayToSorted = __TS__ArrayToSorted,
-  __TS__ArrayToSpliced = __TS__ArrayToSpliced,
-  __TS__ArrayWith = __TS__ArrayWith,
-  __TS__AsyncAwaiter = __TS__AsyncAwaiter,
-  __TS__Await = __TS__Await,
+  __TS__Promise = __TS__Promise,
+  __TS__New = __TS__New,
   __TS__Class = __TS__Class,
-  __TS__ClassExtends = __TS__ClassExtends,
-  __TS__CloneDescriptor = __TS__CloneDescriptor,
-  __TS__CountVarargs = __TS__CountVarargs,
-  __TS__Decorate = __TS__Decorate,
-  __TS__DecorateLegacy = __TS__DecorateLegacy,
-  __TS__DecorateParam = __TS__DecorateParam,
-  __TS__Delete = __TS__Delete,
-  __TS__DelegatedYield = __TS__DelegatedYield,
-  __TS__DescriptorGet = __TS__DescriptorGet,
-  __TS__DescriptorSet = __TS__DescriptorSet,
+  __TS__StringSplit = __TS__StringSplit,
+  __TS__ArrayIsArray = __TS__ArrayIsArray,
   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,
-  __TS__LuaIteratorSpread = __TS__LuaIteratorSpread,
-  Map = Map,
-  __TS__MapGroupBy = __TS__MapGroupBy,
-  __TS__Match = __TS__Match,
-  __TS__MathAtan2 = __TS__MathAtan2,
-  __TS__MathModf = __TS__MathModf,
-  __TS__MathSign = __TS__MathSign,
-  __TS__MathTrunc = __TS__MathTrunc,
-  __TS__New = __TS__New,
-  __TS__Number = __TS__Number,
-  __TS__NumberIsFinite = __TS__NumberIsFinite,
-  __TS__NumberIsInteger = __TS__NumberIsInteger,
-  __TS__NumberIsNaN = __TS__NumberIsNaN,
-  __TS__ParseInt = __TS__ParseInt,
-  __TS__ParseFloat = __TS__ParseFloat,
-  __TS__NumberToString = __TS__NumberToString,
-  __TS__NumberToFixed = __TS__NumberToFixed,
-  __TS__ObjectAssign = __TS__ObjectAssign,
-  __TS__ObjectDefineProperty = __TS__ObjectDefineProperty,
-  __TS__ObjectEntries = __TS__ObjectEntries,
-  __TS__ObjectFromEntries = __TS__ObjectFromEntries,
-  __TS__ObjectGetOwnPropertyDescriptor = __TS__ObjectGetOwnPropertyDescriptor,
-  __TS__ObjectGetOwnPropertyDescriptors = __TS__ObjectGetOwnPropertyDescriptors,
-  __TS__ObjectGroupBy = __TS__ObjectGroupBy,
-  __TS__ObjectKeys = __TS__ObjectKeys,
-  __TS__ObjectRest = __TS__ObjectRest,
-  __TS__ObjectValues = __TS__ObjectValues,
-  __TS__ParseFloat = __TS__ParseFloat,
-  __TS__ParseInt = __TS__ParseInt,
-  __TS__Promise = __TS__Promise,
-  __TS__PromiseAll = __TS__PromiseAll,
-  __TS__PromiseAllSettled = __TS__PromiseAllSettled,
-  __TS__PromiseAny = __TS__PromiseAny,
-  __TS__PromiseRace = __TS__PromiseRace,
-  Set = Set,
-  __TS__SetDescriptor = __TS__SetDescriptor,
-  __TS__SparseArrayNew = __TS__SparseArrayNew,
-  __TS__SparseArrayPush = __TS__SparseArrayPush,
-  __TS__SparseArraySpread = __TS__SparseArraySpread,
-  WeakMap = WeakMap,
-  WeakSet = WeakSet,
-  __TS__SourceMapTraceBack = __TS__SourceMapTraceBack,
-  __TS__Spread = __TS__Spread,
-  __TS__StringAccess = __TS__StringAccess,
-  __TS__StringCharAt = __TS__StringCharAt,
-  __TS__StringCharCodeAt = __TS__StringCharCodeAt,
-  __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,
-  __TS__Using = __TS__Using,
-  __TS__UsingAsync = __TS__UsingAsync
+  URIError = URIError
 }