typescript-to-lua 1.10.0-beta.0 → 1.10.1

package/dist/lualib/ArraySplice.lua

@@ -1,77 +0,0 @@
-local function __TS__ArraySplice(self, ...)
-    local args = {...}
-    local len = #self
-    local actualArgumentCount = select("#", ...)
-    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
-        local ____deleteCount_0 = deleteCount
-        if ____deleteCount_0 == nil then
-            ____deleteCount_0 = 0
-        end
-        actualDeleteCount = ____deleteCount_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

package/dist/lualib/ArrayToObject.lua

@@ -1,7 +0,0 @@
-local function __TS__ArrayToObject(self)
-    local object = {}
-    for i = 1, #self do
-        object[i - 1] = self[i]
-    end
-    return object
-end

package/dist/lualib/ArrayUnshift.lua

@@ -1,14 +0,0 @@
-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

package/dist/lualib/Await.lua

@@ -1,54 +0,0 @@
-local function __TS__AsyncAwaiter(generator)
-    return __TS__New(
-        __TS__Promise,
-        function(____, resolve, reject)
-            local adopt, fulfilled, step, resolved, asyncCoroutine
-            function adopt(self, value)
-                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)
-                if success then
-                    step(nil, resultOrError)
-                else
-                    reject(nil, resultOrError)
-                end
-            end
-            function step(self, result)
-                if resolved then
-                    return
-                end
-                if coroutine.status(asyncCoroutine) == "dead" then
-                    resolve(nil, result)
-                else
-                    local ____self_1 = adopt(nil, result)
-                    ____self_1["then"](____self_1, fulfilled, reject)
-                end
-            end
-            resolved = false
-            asyncCoroutine = coroutine.create(generator)
-            local success, resultOrError = coroutine.resume(
-                asyncCoroutine,
-                function(____, v)
-                    resolved = true
-                    local ____self_2 = adopt(nil, v)
-                    ____self_2["then"](____self_2, resolve, reject)
-                end
-            )
-            if success then
-                step(nil, resultOrError)
-            else
-                reject(nil, resultOrError)
-            end
-        end
-    )
-end
-local function __TS__Await(thing)
-    return coroutine.yield(thing)
-end

package/dist/lualib/Class.lua

@@ -1,6 +0,0 @@
-local function __TS__Class(self)
-    local c = {prototype = {}}
-    c.prototype.__index = c.prototype
-    c.prototype.constructor = c
-    return c
-end

package/dist/lualib/ClassExtends.lua

@@ -1,24 +0,0 @@
-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
-    end
-    setmetatable(target.prototype, base.prototype)
-    if type(base.prototype.__index) == "function" then
-        target.prototype.__index = base.prototype.__index
-    end
-    if type(base.prototype.__newindex) == "function" then
-        target.prototype.__newindex = base.prototype.__newindex
-    end
-    if type(base.prototype.__tostring) == "function" then
-        target.prototype.__tostring = base.prototype.__tostring
-    end
-end

package/dist/lualib/CloneDescriptor.lua

@@ -1,28 +0,0 @@
-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

package/dist/lualib/Decorate.lua

@@ -1,36 +0,0 @@
-local function __TS__Decorate(decorators, target, key, desc)
-    local result = target
-    do
-        local i = #decorators
-        while i >= 0 do
-            local decorator = decorators[i + 1]
-            if decorator 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

package/dist/lualib/DecorateParam.lua

@@ -1,3 +0,0 @@
-local function __TS__DecorateParam(paramIndex, decorator)
-    return function(____, target, key) return decorator(nil, target, key, paramIndex) end
-end

package/dist/lualib/DelegatedYield.lua

@@ -1,34 +0,0 @@
-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

package/dist/lualib/Delete.lua

@@ -1,19 +0,0 @@
-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

package/dist/lualib/Error.lua

@@ -1,77 +0,0 @@
-local Error, RangeError, ReferenceError, SyntaxError, TypeError, URIError
-do
-    local function getErrorStack(self, constructor)
-        local level = 1
-        while true do
-            local info = debug.getinfo(level, "f")
-            level = level + 1
-            if not info then
-                level = 1
-                break
-            elseif info.func == constructor then
-                break
-            end
-        end
-        return debug.traceback(nil, level)
-    end
-    local function wrapErrorToString(self, getDescription)
-        return function(self)
-            local description = getDescription(self)
-            local caller = debug.getinfo(3, "f")
-            if _VERSION == "Lua 5.1" or caller and caller.func ~= error then
-                return description
-            else
-                return (tostring(description) .. "\n") .. self.stack
-            end
-        end
-    end
-    local function initErrorClass(self, Type, name)
-        Type.name = name
-        return setmetatable(
-            Type,
-            {__call = function(____, _self, message) return __TS__New(Type, message) end}
-        )
-    end
-    local ____initErrorClass_2 = initErrorClass
-    local ____class_0 = __TS__Class()
-    ____class_0.name = ""
-    function ____class_0.prototype.____constructor(self, message)
-        if message == nil then
-            message = ""
-        end
-        self.message = message
-        self.name = "Error"
-        self.stack = getErrorStack(nil, self.constructor.new)
-        local metatable = getmetatable(self)
-        if not metatable.__errorToStringPatched then
-            metatable.__errorToStringPatched = true
-            metatable.__tostring = wrapErrorToString(nil, metatable.__tostring)
-        end
-    end
-    function ____class_0.prototype.__tostring(self)
-        local ____temp_1
-        if self.message ~= "" then
-            ____temp_1 = (self.name .. ": ") .. self.message
-        else
-            ____temp_1 = self.name
-        end
-        return ____temp_1
-    end
-    Error = ____initErrorClass_2(nil, ____class_0, "Error")
-    local function createErrorClass(self, name)
-        local ____initErrorClass_4 = initErrorClass
-        local ____class_3 = __TS__Class()
-        ____class_3.name = ____class_3.name
-        __TS__ClassExtends(____class_3, Error)
-        function ____class_3.prototype.____constructor(self, ...)
-            ____class_3.____super.prototype.____constructor(self, ...)
-            self.name = name
-        end
-        return ____initErrorClass_4(nil, ____class_3, name)
-    end
-    RangeError = createErrorClass(nil, "RangeError")
-    ReferenceError = createErrorClass(nil, "ReferenceError")
-    SyntaxError = createErrorClass(nil, "SyntaxError")
-    TypeError = createErrorClass(nil, "TypeError")
-    URIError = createErrorClass(nil, "URIError")
-end

package/dist/lualib/FunctionBind.lua

@@ -1,11 +0,0 @@
-local function __TS__FunctionBind(fn, ...)
-    local boundArgs = {...}
-    return function(____, ...)
-        local args = {...}
-        __TS__ArrayUnshift(
-            args,
-            __TS__Unpack(boundArgs)
-        )
-        return fn(__TS__Unpack(args))
-    end
-end

package/dist/lualib/Generator.lua

@@ -1,38 +0,0 @@
-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 = select("#", ...)
-            return {
-                ____coroutine = coroutine.create(function()
-                    local ____fn_1 = fn
-                    local ____unpack_0 = unpack
-                    if ____unpack_0 == nil then
-                        ____unpack_0 = table.unpack
-                    end
-                    return ____fn_1(____unpack_0(args, 1, argsLength))
-                end),
-                [Symbol.iterator] = generatorIterator,
-                next = generatorNext
-            }
-        end
-    end
-end

package/dist/lualib/InstanceOf.lua

@@ -1,18 +0,0 @@
-local function __TS__InstanceOf(obj, classTbl)
-    if type(classTbl) ~= "table" then
-        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)
-    end
-    if type(obj) == "table" then
-        local luaClass = obj.constructor
-        while luaClass ~= nil do
-            if luaClass == classTbl then
-                return true
-            end
-            luaClass = luaClass.____super
-        end
-    end
-    return false
-end

package/dist/lualib/InstanceOfObject.lua

@@ -1,4 +0,0 @@
-local function __TS__InstanceOfObject(value)
-    local valueType = type(value)
-    return valueType == "table" or valueType == "function"
-end

package/dist/lualib/Iterator.lua

@@ -1,40 +0,0 @@
-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

package/dist/lualib/LuaIteratorSpread.lua

@@ -1,9 +0,0 @@
-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

package/dist/lualib/Map.lua

@@ -1,140 +0,0 @@
-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 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
-        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 items = self.items
-        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, 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 items = self.items
-        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 = items[key]}
-                key = nextKey[key]
-                return result
-            end
-        }
-    end
-    Map[Symbol.species] = Map
-end

package/dist/lualib/MathAtan2.lua

@@ -1 +0,0 @@
-local __TS__MathAtan2 = math.atan2 or math.atan

package/dist/lualib/MathSign.lua

@@ -1,8 +0,0 @@
-local function __TS__MathSign(val)
-    if val > 0 then
-        return 1
-    elseif val < 0 then
-        return -1
-    end
-    return 0
-end

package/dist/lualib/New.lua

@@ -1,5 +0,0 @@
-local function __TS__New(target, ...)
-    local instance = setmetatable({}, target.prototype)
-    instance:____constructor(...)
-    return instance
-end