warscript 0.0.1-dev.404878c

package/utility/json.lua

@@ -0,0 +1,400 @@
+--
+-- json.lua
+--
+-- Copyright (c) 2019 rxi
+--
+-- 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.
+--
+
+local json = { _version = "0.1.2" }
+
+-------------------------------------------------------------------------------
+-- Encode
+-------------------------------------------------------------------------------
+
+local encode
+
+local escape_char_map = {
+    [ "\\" ] = "\\\\",
+    [ "\"" ] = "\\\"",
+    [ "\b" ] = "\\b",
+    [ "\f" ] = "\\f",
+    [ "\n" ] = "\\n",
+    [ "\r" ] = "\\r",
+    [ "\t" ] = "\\t",
+}
+
+local escape_char_map_inv = { [ "\\/" ] = "/" }
+for k, v in pairs(escape_char_map) do
+    escape_char_map_inv[v] = k
+end
+
+
+local function escape_char(c)
+    return escape_char_map[c] or string.format("\\u%04x", c:byte())
+end
+
+
+local function encode_nil(val)
+    return "null"
+end
+
+
+local function encode_table(val, stack)
+    local res = {}
+    stack = stack or {}
+
+    -- Circular reference?
+    if stack[val] then error("circular reference") end
+
+    stack[val] = true
+
+    if rawget(val, 1) ~= nil or next(val) == nil then
+        -- Treat as array -- check keys are valid and it is not sparse
+        local n = 0
+        for k in pairs(val) do
+            if type(k) ~= "number" then
+                error("invalid table: mixed or invalid key types")
+            end
+            n = n + 1
+        end
+        if n ~= #val then
+            error("invalid table: sparse array")
+        end
+        -- Encode
+        for i, v in ipairs(val) do
+            table.insert(res, encode(v, stack))
+        end
+        stack[val] = nil
+        return "[" .. table.concat(res, ",") .. "]"
+
+    else
+        -- Treat as an object
+        for k, v in pairs(val) do
+            if type(k) ~= "string" then
+                error("invalid table: mixed or invalid key types")
+            end
+            table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
+        end
+        stack[val] = nil
+        return "{" .. table.concat(res, ",") .. "}"
+    end
+end
+
+
+local function encode_string(val)
+    return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
+end
+
+
+local function encode_number(val)
+    -- Check for NaN, -inf and inf
+    if val ~= val or val <= -math.huge or val >= math.huge then
+        error("unexpected number value '" .. tostring(val) .. "'")
+    end
+    return string.format("%.14g", val)
+end
+
+
+local type_func_map = {
+    [ "nil"     ] = encode_nil,
+    [ "table"   ] = encode_table,
+    [ "string"  ] = encode_string,
+    [ "number"  ] = encode_number,
+    [ "boolean" ] = tostring,
+}
+
+
+encode = function(val, stack)
+    local t = type(val)
+    local f = type_func_map[t]
+    if f then
+        return f(val, stack)
+    end
+    error("unexpected type '" .. t .. "'")
+end
+
+
+function json.encode(val)
+    return ( encode(val) )
+end
+
+
+-------------------------------------------------------------------------------
+-- Decode
+-------------------------------------------------------------------------------
+
+local parse
+
+local function create_set(...)
+    local res = {}
+    for i = 1, select("#", ...) do
+        res[ select(i, ...) ] = true
+    end
+    return res
+end
+
+local space_chars   = create_set(" ", "\t", "\r", "\n")
+local delim_chars   = create_set(" ", "\t", "\r", "\n", "]", "}", ",")
+local escape_chars  = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u")
+local literals      = create_set("true", "false", "null")
+
+local literal_map = {
+    [ "true"  ] = true,
+    [ "false" ] = false,
+    [ "null"  ] = nil,
+}
+
+
+local function next_char(str, idx, set, negate)
+    for i = idx, #str do
+        if set[str:sub(i, i)] ~= negate then
+            return i
+        end
+    end
+    return #str + 1
+end
+
+
+local function decode_error(str, idx, msg)
+    local line_count = 1
+    local col_count = 1
+    for i = 1, idx - 1 do
+        col_count = col_count + 1
+        if str:sub(i, i) == "\n" then
+            line_count = line_count + 1
+            col_count = 1
+        end
+    end
+    error( string.format("%s at line %d col %d", msg, line_count, col_count) )
+end
+
+
+local function codepoint_to_utf8(n)
+    -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa
+    local f = math.floor
+    if n <= 0x7f then
+        return string.char(n)
+    elseif n <= 0x7ff then
+        return string.char(f(n / 64) + 192, n % 64 + 128)
+    elseif n <= 0xffff then
+        return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128)
+    elseif n <= 0x10ffff then
+        return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128,
+                f(n % 4096 / 64) + 128, n % 64 + 128)
+    end
+    error( string.format("invalid unicode codepoint '%x'", n) )
+end
+
+
+local function parse_unicode_escape(s)
+    local n1 = tonumber( s:sub(3, 6),  16 )
+    local n2 = tonumber( s:sub(9, 12), 16 )
+    -- Surrogate pair?
+    if n2 then
+        return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000)
+    else
+        return codepoint_to_utf8(n1)
+    end
+end
+
+
+local function parse_string(str, i)
+    local has_unicode_escape = false
+    local has_surrogate_escape = false
+    local has_escape = false
+    local last
+    for j = i + 1, #str do
+        local x = str:byte(j)
+
+        if x < 32 then
+            decode_error(str, j, "control character in string")
+        end
+
+        if last == 92 then -- "\\" (escape char)
+            if x == 117 then -- "u" (unicode escape sequence)
+                local hex = str:sub(j + 1, j + 5)
+                if not hex:find("%x%x%x%x") then
+                    decode_error(str, j, "invalid unicode escape in string")
+                end
+                if hex:find("^[dD][89aAbB]") then
+                    has_surrogate_escape = true
+                else
+                    has_unicode_escape = true
+                end
+            else
+                local c = string.char(x)
+                if not escape_chars[c] then
+                    decode_error(str, j, "invalid escape char '" .. c .. "' in string")
+                end
+                has_escape = true
+            end
+            last = nil
+
+        elseif x == 34 then -- '"' (end of string)
+            local s = str:sub(i + 1, j - 1)
+            if has_surrogate_escape then
+                s = s:gsub("\\u[dD][89aAbB]..\\u....", parse_unicode_escape)
+            end
+            if has_unicode_escape then
+                s = s:gsub("\\u....", parse_unicode_escape)
+            end
+            if has_escape then
+                s = s:gsub("\\.", escape_char_map_inv)
+            end
+            return s, j + 1
+
+        else
+            last = x
+        end
+    end
+    decode_error(str, i, "expected closing quote for string")
+end
+
+
+local function parse_number(str, i)
+    local x = next_char(str, i, delim_chars)
+    local s = str:sub(i, x - 1)
+    local n = tonumber(s)
+    if not n then
+        decode_error(str, i, "invalid number '" .. s .. "'")
+    end
+    return n, x
+end
+
+
+local function parse_literal(str, i)
+    local x = next_char(str, i, delim_chars)
+    local word = str:sub(i, x - 1)
+    if not literals[word] then
+        decode_error(str, i, "invalid literal '" .. word .. "'")
+    end
+    return literal_map[word], x
+end
+
+
+local function parse_array(str, i)
+    local res = {}
+    local n = 1
+    i = i + 1
+    while 1 do
+        local x
+        i = next_char(str, i, space_chars, true)
+        -- Empty / end of array?
+        if str:sub(i, i) == "]" then
+            i = i + 1
+            break
+        end
+        -- Read token
+        x, i = parse(str, i)
+        res[n] = x
+        n = n + 1
+        -- Next token
+        i = next_char(str, i, space_chars, true)
+        local chr = str:sub(i, i)
+        i = i + 1
+        if chr == "]" then break end
+        if chr ~= "," then decode_error(str, i, "expected ']' or ','") end
+    end
+    return res, i
+end
+
+
+local function parse_object(str, i)
+    local res = {}
+    i = i + 1
+    while 1 do
+        local key, val
+        i = next_char(str, i, space_chars, true)
+        -- Empty / end of object?
+        if str:sub(i, i) == "}" then
+            i = i + 1
+            break
+        end
+        -- Read key
+        if str:sub(i, i) ~= '"' then
+            decode_error(str, i, "expected string for key")
+        end
+        key, i = parse(str, i)
+        -- Read ':' delimiter
+        i = next_char(str, i, space_chars, true)
+        if str:sub(i, i) ~= ":" then
+            decode_error(str, i, "expected ':' after key")
+        end
+        i = next_char(str, i + 1, space_chars, true)
+        -- Read value
+        val, i = parse(str, i)
+        -- Set
+        res[key] = val
+        -- Next token
+        i = next_char(str, i, space_chars, true)
+        local chr = str:sub(i, i)
+        i = i + 1
+        if chr == "}" then break end
+        if chr ~= "," then decode_error(str, i, "expected '}' or ','") end
+    end
+    return res, i
+end
+
+
+local char_func_map = {
+    [ '"' ] = parse_string,
+    [ "0" ] = parse_number,
+    [ "1" ] = parse_number,
+    [ "2" ] = parse_number,
+    [ "3" ] = parse_number,
+    [ "4" ] = parse_number,
+    [ "5" ] = parse_number,
+    [ "6" ] = parse_number,
+    [ "7" ] = parse_number,
+    [ "8" ] = parse_number,
+    [ "9" ] = parse_number,
+    [ "-" ] = parse_number,
+    [ "t" ] = parse_literal,
+    [ "f" ] = parse_literal,
+    [ "n" ] = parse_literal,
+    [ "[" ] = parse_array,
+    [ "{" ] = parse_object,
+}
+
+
+parse = function(str, idx)
+    local chr = str:sub(idx, idx)
+    local f = char_func_map[chr]
+    if f then
+        return f(str, idx)
+    end
+    decode_error(str, idx, "unexpected character '" .. chr .. "'")
+end
+
+
+function json.decode(str)
+    if type(str) ~= "string" then
+        error("expected argument of type string, got " .. type(str))
+    end
+    local res, idx = parse(str, next_char(str, 1, space_chars, true))
+    idx = next_char(str, idx, space_chars, true)
+    if idx <= #str then
+        decode_error(str, idx, "trailing garbage")
+    end
+    return res
+end
+
+
+return json

package/utility/linked-set.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+type IteratorState<T extends AnyNotNil> = {
+    t: LuaMap<T, T>;
+    n?: T;
+};
+type OneSidedTypeGuard = {
+    readonly __oneSidedTypeGuard: unique symbol;
+};
+export interface ReadonlyLinkedSet<T extends AnyNotNil> extends LuaPairsKeyIterable<T> {
+    copyOf(): LinkedSet<T>;
+    first(): T | undefined;
+    last(): T | undefined;
+    next(key: T): T | undefined;
+    previous(key: T): T | undefined;
+    contains(key: AnyNotNil): key is T & OneSidedTypeGuard;
+    size: number;
+    forEach<Args extends any[]>(action: (value: T, ...args: Args) => void, ...args: Args): void;
+    toArray(): T[];
+    sumOf(selector: ((value: T) => number) | KeysOfType<T, number>): number;
+}
+export interface LinkedSet<T extends AnyNotNil> extends LuaPairsKeyIterable<T> {
+    readonly __linkedSet: unique symbol;
+}
+export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet<T> {
+    private n;
+    private p;
+    private f?;
+    private l?;
+    private s;
+    copyOf(): LinkedSet<T>;
+    first(): T | undefined;
+    last(): T | undefined;
+    next(key: T): T | undefined;
+    previous(key: T): T | undefined;
+    add(key: T): boolean;
+    remove(key: T): boolean;
+    contains(key: AnyNotNil): key is T & OneSidedTypeGuard;
+    clear(): void;
+    get size(): number;
+    forEach<Args extends any[]>(action: (value: T, ...args: Args) => void, ...args: Args): void;
+    toArray(): T[];
+    sumOf(selector: ((value: T) => number) | KeysOfType<T, number>): number;
+    sortBy<R>(selector: ((value: T) => R) | KeysOfType<T, R>): void;
+    protected __pairs(this: LinkedSet<T>): LuaIterator<T | undefined, IteratorState<T>>;
+}
+export declare const linkedSetOf: <T extends AnyNotNil>(...elements: readonly T[]) => LinkedSet<T>;
+export declare const linkedSetOfNotNull: <T extends AnyNotNil>(...elements: readonly (T | null | undefined)[]) => LinkedSet<T>;
+export {};

package/utility/linked-set.lua

@@ -0,0 +1,181 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____arrays = require("utility.arrays")
+local sortBy = ____arrays.sortBy
+local function linkedSetNext(state)
+    local n = state.n
+    state.n = state.t[n]
+    return n
+end
+____exports.LinkedSet = __TS__Class()
+local LinkedSet = ____exports.LinkedSet
+LinkedSet.name = "LinkedSet"
+function LinkedSet.prototype.____constructor(self)
+    self.n = {}
+    self.p = {}
+    self.s = 0
+end
+function LinkedSet.prototype.copyOf(self)
+    local copy = __TS__New(____exports.LinkedSet)
+    local n = copy.n
+    for key, value in pairs(self.n) do
+        n[key] = value
+    end
+    local p = copy.p
+    for key, value in pairs(self.p) do
+        p[key] = value
+    end
+    copy.f = self.f
+    copy.l = self.l
+    copy.s = self.s
+    return copy
+end
+function LinkedSet.prototype.first(self)
+    return self.f
+end
+function LinkedSet.prototype.last(self)
+    return self.l
+end
+function LinkedSet.prototype.next(self, key)
+    return self.n[key]
+end
+function LinkedSet.prototype.previous(self, key)
+    return self.p[key]
+end
+function LinkedSet.prototype.add(self, key)
+    local n = self.n
+    if n[key] ~= nil then
+        return false
+    end
+    local l = self.l
+    if l == nil then
+        self.f = key
+        self.l = key
+        self.s = 1
+    elseif l ~= key then
+        n[l] = key
+        self.p[key] = l
+        self.l = key
+        self.s = self.s + 1
+    else
+        return false
+    end
+    return true
+end
+function LinkedSet.prototype.remove(self, key)
+    local n = self.n
+    local next = n[key]
+    n[key] = nil
+    local p = self.p
+    local previous = p[key]
+    p[key] = nil
+    if next ~= nil and previous ~= nil then
+        n[previous] = next
+        p[next] = previous
+    elseif next ~= nil then
+        self.f = next
+        p[next] = nil
+    elseif previous ~= nil then
+        self.l = previous
+        n[previous] = nil
+    elseif self.l == key then
+        self.f = nil
+        self.l = nil
+    else
+        return false
+    end
+    self.s = self.s - 1
+    return true
+end
+function LinkedSet.prototype.contains(self, key)
+    return self.n[key] ~= nil or self.l == key
+end
+function LinkedSet.prototype.clear(self)
+    self.n = {}
+    self.p = {}
+    self.f = nil
+    self.l = nil
+    self.s = 0
+end
+function LinkedSet.prototype.forEach(self, action, ...)
+    local n = self.n
+    local c = self.f
+    while c ~= nil do
+        action(c, ...)
+        c = n[c]
+    end
+end
+function LinkedSet.prototype.toArray(self)
+    local array = {}
+    local i = 1
+    local n = self.n
+    local c = self.f
+    while c ~= nil do
+        array[i] = c
+        i = i + 1
+        c = n[c]
+    end
+    return array
+end
+function LinkedSet.prototype.sumOf(self, selector)
+    local sum = 0
+    local n = self.n
+    local c = self.f
+    if type(selector) == "function" then
+        while c ~= nil do
+            sum = sum + selector(c)
+            c = n[c]
+        end
+    else
+        while c ~= nil do
+            sum = sum + c[selector]
+            c = n[c]
+        end
+    end
+    return sum
+end
+function LinkedSet.prototype.sortBy(self, selector)
+    local array = self:toArray()
+    sortBy(array, selector)
+    local n = self.n
+    local p = self.p
+    local s = self.s
+    for i = 1, s do
+        n[array[i]] = array[i + 1]
+        p[array[i]] = array[i - 2 + 1]
+    end
+    self.f = array[1]
+    self.l = array[s]
+end
+function LinkedSet.prototype.__pairs(self)
+    return linkedSetNext, {t = self.n, n = self.f}, nil
+end
+__TS__SetDescriptor(
+    LinkedSet.prototype,
+    "size",
+    {get = function(self)
+        return self.s
+    end},
+    true
+)
+____exports.linkedSetOf = function(...)
+    local linkedSet = __TS__New(____exports.LinkedSet)
+    for i = 1, select("#", ...) do
+        linkedSet:add((select(i, ...)))
+    end
+    return linkedSet
+end
+____exports.linkedSetOfNotNull = function(...)
+    local linkedSet = __TS__New(____exports.LinkedSet)
+    for i = 1, select("#", ...) do
+        local element = (select(i, ...))
+        if element ~= nil then
+            linkedSet:add(element)
+        end
+    end
+    return linkedSet
+end
+return ____exports

package/utility/lua-maps.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+import { Flatten, TupleOf } from "./types";
+export declare const luaMapOf: <K extends AnyNotNil, V>(...pairs: Flatten<TupleOf<[K, V], 0 | 2 | 1 | 22 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 27 | 31 | 40 | 30 | 32 | 23 | 24 | 25 | 26 | 28 | 29 | 33 | 34 | 35 | 36 | 37 | 38 | 39>>) => LuaMap<K, V>;
+export declare const luaMapInvert: <K extends AnyNotNil, V extends AnyNotNil>(luaMap: LuaMap<K, V>) => LuaMap<V, K>;
+export declare const mapValues: <K extends AnyNotNil, V1, V2>(luaMap: LuaMap<K, V1>, transform: (value: V1) => V2) => LuaMap<K, V2>;

package/utility/lua-maps.lua

@@ -0,0 +1,25 @@
+local ____exports = {}
+local select = _G.select
+____exports.luaMapOf = function(...)
+    local luaMap = {}
+    for i = 1, select("#", ...), 2 do
+        local key, value = select(i, ...)
+        luaMap[key] = value
+    end
+    return luaMap
+end
+____exports.luaMapInvert = function(luaMap)
+    local invertLuaMap = {}
+    for key, value in pairs(luaMap) do
+        invertLuaMap[value] = key
+    end
+    return invertLuaMap
+end
+____exports.mapValues = function(luaMap, transform)
+    local result = {}
+    for key, value in pairs(luaMap) do
+        result[key] = transform(value)
+    end
+    return result
+end
+return ____exports

package/utility/lua-sets.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+export declare const luaSetOf: <T extends AnyNotNil>(...elements: readonly T[]) => LuaSet<T>;
+export declare const luaSetOfNotNull: <T extends AnyNotNil>(...elements: readonly (T | null | undefined)[]) => LuaSet<T>;
+export declare const luaSetIntersection: <T extends AnyNotNil>(firstLuaSet: ReadonlyLuaSet<T>, secondLuaSet: ReadonlyLuaSet<T>) => LuaSet<T>;
+export declare const luaSetContainsAnyOf: <T extends AnyNotNil>(luaSet: ReadonlyLuaSet<T>, ...elements: readonly T[]) => boolean;

package/utility/lua-sets.lua

@@ -0,0 +1,37 @@
+local ____exports = {}
+local select = _G.select
+____exports.luaSetOf = function(...)
+    local luaSet = {}
+    for i = 1, select("#", ...) do
+        luaSet[(select(i, ...))] = true
+    end
+    return luaSet
+end
+____exports.luaSetOfNotNull = function(...)
+    local luaSet = {}
+    for i = 1, select("#", ...) do
+        local value = select(i, ...)
+        if value ~= nil then
+            luaSet[value] = true
+        end
+    end
+    return luaSet
+end
+____exports.luaSetIntersection = function(firstLuaSet, secondLuaSet)
+    local luaSet = {}
+    for element in pairs(firstLuaSet) do
+        if secondLuaSet[element] ~= nil then
+            luaSet[element] = true
+        end
+    end
+    return luaSet
+end
+____exports.luaSetContainsAnyOf = function(luaSet, ...)
+    for i = 1, select("#", ...) do
+        if luaSet[(select(i, ...))] ~= nil then
+            return true
+        end
+    end
+    return false
+end
+return ____exports

package/utility/lzw.d.ts

@@ -0,0 +1,2 @@
+export function compress(this: void, input: string): string
+export function decompress(this: void, input: string): string