@noita-ts/pollnet 0.1.0 → 0.3.0

package/LICENSE-pollnet

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 probable-basilisk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/async.d.ts

@@ -0,0 +1,73 @@
+import pollnet from ".";
+export declare namespace compat {
+    /**
+     * Run `body` inside a reactor coroutine and get its completion as a Promise.
+     * `body` may freely use socket.await() / other yield-based pollnet APIs.
+     * Errors inside body reject the promise.
+     */
+    const asyncify: <T>(reactor: pollnet.Reactor, body: () => T) => Promise<T>;
+    /**
+     * Parks the *current coroutine* until the promise settles, then returns its
+     * value or rethrows its rejection.
+     * Only call from inside a reactor coroutine (`reactor.run(() => { .. HERE .. })`).
+     */
+    const yieldPromise: <T>(p: Promise<T>) => T;
+}
+/**
+ * Promise-friendly wrapper around a {@link pollnet.Reactor}.
+ *
+ * Lets you drive yield-based pollnet coroutines while exposing their results
+ * as Promises. Call {@link poll} regularly (e.g. once per frame) to advance
+ * all running coroutines.
+ */
+export declare class AsyncReactor {
+    private reactor;
+    constructor();
+    /**
+     * Advance every coroutine currently running on the reactor by one step.
+     * Must be called periodically for spawned work to make progress.
+     */
+    poll(): number;
+    /**
+     * Run `body` as a reactor coroutine and return its result as a Promise.
+     * `body` may use yield-based pollnet APIs (e.g. `socket.await()`).
+     */
+    spawn<T>(body: () => T): Promise<T>;
+    /**
+     * Async version of `pollnet.Reactor.run_server`.
+     *
+     * Accept connections on `server_sock`, spawning a coroutine that runs
+     * `client_body` for each incoming client. `client_body` receives the client
+     * socket and its remote address, and may itself return a Promise which the
+     * coroutine parks on until it settles.
+     */
+    runServer(server_sock: pollnet.Socket, client_body: (sock: pollnet.Socket, addr: string) => Promise<void>): void;
+}
+export declare class HttpResponse {
+    status: number;
+    headers: string;
+    body: string;
+    constructor(status: number, headers: string, body: string);
+    /**
+     * Parse the raw header block into a map.
+     * Header names seen more than once collapse into an array of their values, in
+     * order.
+     */
+    parseHeaders(): Record<string, string | string[]>;
+}
+/**
+ * Tiny async HTTP client built on top of an {@link AsyncReactor}.
+ * Requests run as reactor coroutines and resolve to an {@link HttpResponse}.
+ */
+export declare class HttpClient {
+    private reactor;
+    constructor(reactor: AsyncReactor);
+    /**
+     * Perform an HTTP GET.
+     */
+    get(url: string, headers?: Record<string, string | string[]> | string): Promise<HttpResponse>;
+    /**
+     * Perform an HTTP POST with an optional request `body`.
+     */
+    post(url: string, headers?: Record<string, string | string[]> | string, body?: string): Promise<HttpResponse>;
+}

package/dist/async.lua

@@ -0,0 +1,173 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Promise = ____lualib.__TS__Promise
+local __TS__New = ____lualib.__TS__New
+local __TS__Class = ____lualib.__TS__Class
+local __TS__StringSplit = ____lualib.__TS__StringSplit
+local __TS__ArrayIsArray = ____lualib.__TS__ArrayIsArray
+local Error = ____lualib.Error
+local RangeError = ____lualib.RangeError
+local ReferenceError = ____lualib.ReferenceError
+local SyntaxError = ____lualib.SyntaxError
+local TypeError = ____lualib.TypeError
+local URIError = ____lualib.URIError
+local ____exports = {}
+local _____2E = require("index")
+local pollnet = _____2E.default
+____exports.compat = {}
+local compat = ____exports.compat
+do
+    --- Run `body` inside a reactor coroutine and get its completion as a Promise.
+    -- `body` may freely use socket.await() / other yield-based pollnet APIs.
+    -- Errors inside body reject the promise.
+    compat.asyncify = function(____, reactor, body)
+        return __TS__New(
+            __TS__Promise,
+            function(____, resolve, reject)
+                reactor:run(function()
+                    do
+                        local function ____catch(e)
+                            reject(nil, e)
+                        end
+                        local ____try, ____hasReturned = pcall(function()
+                            resolve(
+                                nil,
+                                body(nil)
+                            )
+                        end)
+                        if not ____try then
+                            ____catch(____hasReturned)
+                        end
+                    end
+                end)
+            end
+        )
+    end
+    --- Parks the *current coroutine* until the promise settles, then returns its
+    -- value or rethrows its rejection.
+    -- Only call from inside a reactor coroutine (`reactor.run(() => { .. HERE .. })`).
+    compat.yieldPromise = function(____, p)
+        local done = false
+        local ok = false
+        local result
+        p["then"](
+            p,
+            function(____, v)
+                done = true
+                ok = true
+                result = v
+            end,
+            function(____, e)
+                done = true
+                ok = false
+                result = e
+            end
+        )
+        while not done do
+            coroutine.yield()
+        end
+        if not ok then
+            error(result, 0)
+        end
+        return result
+    end
+end
+--- Promise-friendly wrapper around a {@link pollnet.Reactor}.
+-- 
+-- Lets you drive yield-based pollnet coroutines while exposing their results
+-- as Promises. Call {@link poll} regularly (e.g. once per frame) to advance
+-- all running coroutines.
+____exports.AsyncReactor = __TS__Class()
+local AsyncReactor = ____exports.AsyncReactor
+AsyncReactor.name = "AsyncReactor"
+function AsyncReactor.prototype.____constructor(self)
+    self.reactor = pollnet.Reactor()
+end
+function AsyncReactor.prototype.poll(self)
+    return self.reactor:update()
+end
+function AsyncReactor.prototype.spawn(self, body)
+    return ____exports.compat:asyncify(self.reactor, body)
+end
+function AsyncReactor.prototype.runServer(self, server_sock, client_body)
+    server_sock:on_connection(function(client_sock, addr)
+        self.reactor:run(function() return ____exports.compat:yieldPromise(client_body(nil, client_sock, addr)) end)
+    end)
+    self.reactor:run(function()
+        while (server_sock:await()) do
+        end
+    end)
+end
+____exports.HttpResponse = __TS__Class()
+local HttpResponse = ____exports.HttpResponse
+HttpResponse.name = "HttpResponse"
+function HttpResponse.prototype.____constructor(self, status, headers, body)
+    self.status = status
+    self.headers = headers
+    self.body = body
+end
+function HttpResponse.prototype.parseHeaders(self)
+    local headers = {}
+    for ____, line in ipairs(__TS__StringSplit(self.headers, "\n")) do
+        do
+            local key, value = unpack(
+                __TS__StringSplit(line, ": ", 2),
+                1,
+                2
+            )
+            if not key or not value then
+                goto __continue23
+            end
+            local prev = headers[key]
+            if not prev then
+                headers[key] = value
+                goto __continue23
+            end
+            if __TS__ArrayIsArray(prev) then
+                prev[#prev + 1] = value
+            else
+                headers[key] = {prev, value}
+            end
+        end
+        ::__continue23::
+    end
+    return headers
+end
+--- Tiny async HTTP client built on top of an {@link AsyncReactor}.
+-- Requests run as reactor coroutines and resolve to an {@link HttpResponse}.
+____exports.HttpClient = __TS__Class()
+local HttpClient = ____exports.HttpClient
+HttpClient.name = "HttpClient"
+function HttpClient.prototype.____constructor(self, reactor)
+    self.reactor = reactor
+end
+function HttpClient.prototype.get(self, url, headers)
+    return self.reactor:spawn(function()
+        local socket = pollnet.http_get(url, headers, false)
+        local msgs, ____error = socket:await_n(3)
+        if not msgs then
+            error(
+                __TS__New(Error, "socket error: " .. ____error),
+                0
+            )
+        end
+        local statusStr, headersStr, respBody = unpack(msgs, 1, 3)
+        local status = tonumber({string.match("^%d+", statusStr)}) or 500
+        return __TS__New(____exports.HttpResponse, status, headersStr, respBody)
+    end)
+end
+function HttpClient.prototype.post(self, url, headers, body)
+    return self.reactor:spawn(function()
+        local socket = pollnet.http_post(url, headers, body, false)
+        local msgs, ____error = socket:await_n(3)
+        if not msgs then
+            error(
+                __TS__New(Error, "socket error: " .. ____error),
+                0
+            )
+        end
+        local statusStr, headersStr, respBody = unpack(msgs, 1, 3)
+        local status = tonumber({string.match("^%d+", statusStr)}) or 500
+        return __TS__New(____exports.HttpResponse, status, headersStr, respBody)
+    end)
+end
+return ____exports

package/{index.d.ts → dist/index.d.ts}

@@ -154,8 +154,7 @@ declare namespace pollnet {
 
     /** Awaits a message (coroutine.yield) */
     await():
-      | LuaMultiReturn<[string, undefined]>
-      | LuaMultiReturn<[false, string]>;
+      LuaMultiReturn<[string, undefined]> | LuaMultiReturn<[false, string]>;
 
     /** Awaits N messages */
     await_n(
@@ -197,12 +196,12 @@ declare namespace pollnet {
     init(): void;
 
     /** Runs a coroutine thread */
-    run(thread_body: (self: Reactor) => Promise<void> | void): void;
+    run(thread_body: (this: Reactor) => void): void;
 
     /** Runs a server with client handler */
     run_server(
       server_sock: Socket,
-      client_body: (sock: Socket, addr: string) => Promise<void> | void,
+      client_body: (sock: Socket, addr: string) => void,
     ): void;
 
     /** Logs messages */

package/dist/lualib_bundle.lua

@@ -0,0 +1,389 @@
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
+local __TS__Symbol, Symbol
+do
+    local symbolMetatable = {__tostring = function(self)
+        return ("Symbol(" .. (self.description or "")) .. ")"
+    end}
+    function __TS__Symbol(description)
+        return setmetatable({description = description}, symbolMetatable)
+    end
+    Symbol = {
+        asyncDispose = __TS__Symbol("Symbol.asyncDispose"),
+        dispose = __TS__Symbol("Symbol.dispose"),
+        iterator = __TS__Symbol("Symbol.iterator"),
+        hasInstance = __TS__Symbol("Symbol.hasInstance"),
+        species = __TS__Symbol("Symbol.species"),
+        toStringTag = __TS__Symbol("Symbol.toStringTag")
+    }
+end
+
+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
+
+local function __TS__Class(self)
+    local c = {prototype = {}}
+    c.prototype.__index = c.prototype
+    c.prototype.constructor = c
+    return c
+end
+
+local __TS__Promise
+do
+    local function makeDeferredPromiseFactory()
+        local resolve
+        local reject
+        local function executor(____, res, rej)
+            resolve = res
+            reject = rej
+        end
+        return function()
+            local promise = __TS__New(__TS__Promise, executor)
+            return promise, resolve, reject
+        end
+    end
+    local makeDeferredPromise = makeDeferredPromiseFactory()
+    local function isPromiseLike(value)
+        return __TS__InstanceOf(value, __TS__Promise)
+    end
+    local function doNothing(self)
+    end
+    local ____pcall = _G.pcall
+    __TS__Promise = __TS__Class()
+    __TS__Promise.name = "__TS__Promise"
+    function __TS__Promise.prototype.____constructor(self, executor)
+        self.state = 0
+        self.fulfilledCallbacks = {}
+        self.rejectedCallbacks = {}
+        local success, ____error = ____pcall(
+            executor,
+            nil,
+            function(____, v) return self:resolve(v) end,
+            function(____, err) return self:reject(err) end
+        )
+        if not success then
+            self:reject(____error)
+        end
+    end
+    function __TS__Promise.resolve(value)
+        if __TS__InstanceOf(value, __TS__Promise) then
+            return value
+        end
+        local promise = __TS__New(__TS__Promise, doNothing)
+        promise.state = 1
+        promise.value = value
+        return promise
+    end
+    function __TS__Promise.reject(reason)
+        local promise = __TS__New(__TS__Promise, doNothing)
+        promise.state = 2
+        promise.rejectionReason = reason
+        return promise
+    end
+    __TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
+        local promise, resolve, reject = makeDeferredPromise()
+        self:addCallbacks(
+            onFulfilled and self:createPromiseResolvingCallback(onFulfilled, resolve, reject) or resolve,
+            onRejected and self:createPromiseResolvingCallback(onRejected, resolve, reject) or reject
+        )
+        return promise
+    end
+    function __TS__Promise.prototype.addCallbacks(self, fulfilledCallback, rejectedCallback)
+        if self.state == 1 then
+            return fulfilledCallback(nil, self.value)
+        end
+        if self.state == 2 then
+            return rejectedCallback(nil, self.rejectionReason)
+        end
+        local ____self_fulfilledCallbacks_0 = self.fulfilledCallbacks
+        ____self_fulfilledCallbacks_0[#____self_fulfilledCallbacks_0 + 1] = fulfilledCallback
+        local ____self_rejectedCallbacks_1 = self.rejectedCallbacks
+        ____self_rejectedCallbacks_1[#____self_rejectedCallbacks_1 + 1] = rejectedCallback
+    end
+    function __TS__Promise.prototype.catch(self, onRejected)
+        return self["then"](self, nil, onRejected)
+    end
+    function __TS__Promise.prototype.finally(self, onFinally)
+        if type(onFinally) ~= "function" then
+            return self["then"](self, onFinally, onFinally)
+        end
+        return self["then"](
+            self,
+            function(____, x)
+                local ____self_2 = __TS__New(
+                    __TS__Promise,
+                    function(____, resolve) return resolve(
+                        nil,
+                        onFinally(nil)
+                    ) end
+                )
+                return ____self_2["then"](
+                    ____self_2,
+                    function() return x end
+                )
+            end,
+            function(____, e)
+                local ____self_3 = __TS__New(
+                    __TS__Promise,
+                    function(____, resolve) return resolve(
+                        nil,
+                        onFinally(nil)
+                    ) end
+                )
+                return ____self_3["then"](
+                    ____self_3,
+                    function()
+                        error(e, 0)
+                    end
+                )
+            end
+        )
+    end
+    function __TS__Promise.prototype.resolve(self, value)
+        if isPromiseLike(value) then
+            return value:addCallbacks(
+                function(____, v) return self:resolve(v) end,
+                function(____, err) return self:reject(err) end
+            )
+        end
+        if self.state == 0 then
+            self.state = 1
+            self.value = value
+            return self:invokeCallbacks(self.fulfilledCallbacks, value)
+        end
+    end
+    function __TS__Promise.prototype.reject(self, reason)
+        if self.state == 0 then
+            self.state = 2
+            self.rejectionReason = reason
+            return self:invokeCallbacks(self.rejectedCallbacks, reason)
+        end
+    end
+    function __TS__Promise.prototype.invokeCallbacks(self, callbacks, value)
+        local callbacksLength = #callbacks
+        if callbacksLength ~= 0 then
+            for i = 1, callbacksLength - 1 do
+                callbacks[i](callbacks, value)
+            end
+            return callbacks[callbacksLength](callbacks, value)
+        end
+    end
+    function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
+        return function(____, value)
+            local success, resultOrError = ____pcall(f, nil, value)
+            if not success then
+                return reject(nil, resultOrError)
+            end
+            return self:handleCallbackValue(resultOrError, resolve, reject)
+        end
+    end
+    function __TS__Promise.prototype.handleCallbackValue(self, value, resolve, reject)
+        if isPromiseLike(value) then
+            local nextpromise = value
+            if nextpromise.state == 1 then
+                return resolve(nil, nextpromise.value)
+            elseif nextpromise.state == 2 then
+                return reject(nil, nextpromise.rejectionReason)
+            else
+                return nextpromise:addCallbacks(resolve, reject)
+            end
+        else
+            return resolve(nil, value)
+        end
+    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 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
+    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
+
+local Error, RangeError, ReferenceError, SyntaxError, TypeError, URIError
+do
+    local function getErrorStack(self, constructor)
+        if debug == nil then
+            return nil
+        end
+        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
+        if __TS__StringIncludes(_VERSION, "Lua 5.0") then
+            return debug.traceback(("[Level " .. tostring(level)) .. "]")
+        elseif _VERSION == "Lua 5.1" then
+            return string.sub(
+                debug.traceback("", level),
+                2
+            )
+        else
+            return debug.traceback(nil, level)
+        end
+    end
+    local function wrapErrorToString(self, getDescription)
+        return function(self)
+            local description = getDescription(self)
+            local caller = debug.getinfo(3, "f")
+            local isClassicLua = __TS__StringIncludes(_VERSION, "Lua 5.0")
+            if isClassicLua or caller and caller.func ~= error then
+                return description
+            else
+                return (description .. "\n") .. tostring(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_1 = 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, __TS__New)
+        local metatable = getmetatable(self)
+        if metatable and not metatable.__errorToStringPatched then
+            metatable.__errorToStringPatched = true
+            metatable.__tostring = wrapErrorToString(nil, metatable.__tostring)
+        end
+    end
+    function ____class_0.prototype.__tostring(self)
+        return self.message ~= "" and (self.name .. ": ") .. self.message or self.name
+    end
+    Error = ____initErrorClass_1(nil, ____class_0, "Error")
+    local function createErrorClass(self, name)
+        local ____initErrorClass_3 = initErrorClass
+        local ____class_2 = __TS__Class()
+        ____class_2.name = ____class_2.name
+        __TS__ClassExtends(____class_2, Error)
+        function ____class_2.prototype.____constructor(self, ...)
+            ____class_2.____super.prototype.____constructor(self, ...)
+            self.name = name
+        end
+        return ____initErrorClass_3(nil, ____class_2, name)
+    end
+    RangeError = createErrorClass(nil, "RangeError")
+    ReferenceError = createErrorClass(nil, "ReferenceError")
+    SyntaxError = createErrorClass(nil, "SyntaxError")
+    TypeError = createErrorClass(nil, "TypeError")
+    URIError = createErrorClass(nil, "URIError")
+end
+
+return {
+  __TS__Promise = __TS__Promise,
+  __TS__New = __TS__New,
+  __TS__Class = __TS__Class,
+  __TS__StringSplit = __TS__StringSplit,
+  __TS__ArrayIsArray = __TS__ArrayIsArray,
+  Error = Error,
+  RangeError = RangeError,
+  ReferenceError = ReferenceError,
+  SyntaxError = SyntaxError,
+  TypeError = TypeError,
+  URIError = URIError
+}

package/package.json

@@ -1,22 +1,34 @@
 {
   "name": "@noita-ts/pollnet",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "files": [
-    "index.lua",
-    "index.d.ts",
+    "dist/**/*.{lua,d.ts}",
     "pollnet.dll",
-    "pollnet-license.txt"
+    "LICENSE-pollnet"
   ],
-  "main": "index",
   "type": "module",
-  "types": "index.d.ts",
+  "main": "dist/index",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index"
+    },
+    "./async": {
+      "types": "./dist/async.d.ts",
+      "default": "./dist/async"
+    }
+  },
   "scripts": {
-    "prepublishOnly": "tsc -p ."
+    "build": "tstl -p . && cp *.lua *.d.ts dist/",
+    "prepublishOnly": "rm -rf dist && npm run build"
   },
   "dependencies": {
-    "@typescript-to-lua/language-extensions": "^1.19.0"
+    "@typescript-to-lua/language-extensions": "^1.19.0",
+    "lua-types": "^2.13.1"
   },
   "devDependencies": {
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2",
+    "typescript-to-lua": "^1.36.0"
   }
 }