warscript 0.0.1-dev.c946175 → 0.0.1-dev.cc49a34

package/utility/arrays.d.ts

@@ -5,6 +5,7 @@ export declare const joinToString: <T>(array: readonly T[], separator: string, t
 export declare const arrayOfNotNull: <T>(...elements: readonly (T | undefined | null)[]) => T[];
 export declare const array: <T, N extends number>(length: N, initialize: (index: number) => T) => TupleOf<T, N>;
 export declare const toLuaSet: <T extends AnyNotNil>(array: readonly T[]) => LuaSet<T>;
+export declare const contains: <T>(array: readonly T[], element: T) => boolean;
 export declare const forEach: <T, Args extends any[]>(array: readonly T[], consumerOrKey: ((value: T, ...args: Args) => void) | KeysOfType<T, (this: T, ...args: Args) => void>, ...args: Args) => void;
 export declare const all: {
     <T>(array: readonly T[], transform: (value: T) => boolean): boolean;
@@ -22,6 +23,7 @@ export declare const mapToLuaSet: {
     <T, R extends AnyNotNil>(array: readonly T[], transform: (value: T) => R): LuaSet<R>;
     <T, K extends KeysOfType<T, AnyNotNil>>(array: readonly T[], key: K): LuaSet<T[K] extends AnyNotNil ? T[K] : never>;
 };
+export declare const flatten: <T>(array: readonly (readonly T[])[]) => T[];
 export declare const flatMap: {
     <T, R>(array: readonly T[], transform: (value: T) => readonly R[]): R[];
     <T, K extends KeysOfType<T, readonly any[]>>(array: readonly T[], key: K): (T[K] extends readonly (infer R)[] ? R : never)[];
@@ -32,7 +34,10 @@ export declare const flatMapToLuaSet: {
 };
 export declare const mapIndexed: <T, R>(array: readonly T[], transform: (index: number, value: T) => R) => R[];
 export declare const associate: <T, K extends AnyNotNil, V>(array: readonly T[], keySelector: (value: T) => K, valueSelector: (value: T) => V) => LuaMap<K, V>;
-export declare const associateBy: <K extends AnyNotNil, V>(array: readonly V[], keySelector: (value: V) => K) => LuaMap<K, V>;
+export declare const associateBy: {
+    <K extends AnyNotNil, V>(array: readonly V[], keySelector: (value: V) => K): LuaMap<K, V>;
+    <K extends KeysOfType<V, AnyNotNil>, V>(array: readonly V[], keySelector: K): LuaMap<V[K] extends AnyNotNil ? V[K] : never, V>;
+};
 export declare const associateByIndexed: <K extends AnyNotNil, V>(array: readonly V[], keySelector: (index: number, value: V) => K) => LuaMap<K, V>;
 export declare const associateWith: <K extends AnyNotNil, V>(array: readonly K[], valueSelector: (value: K) => V) => LuaMap<K, V>;
 export declare const associateWithIndexed: <K extends AnyNotNil, V>(array: readonly K[], valueSelector: (index: number, value: K) => V) => LuaMap<K, V>;
@@ -41,6 +46,10 @@ export declare const average: (array: readonly number[]) => number;
 export declare const sum: (array: readonly number[]) => number;
 export declare const product: (array: readonly number[]) => number;
 export declare const max: (array: readonly number[]) => number;
+export declare const maxBy: {
+    <T, Args extends any[]>(array: readonly T[], selector: (value: T, ...args: Args) => number, ...args: Args): T | undefined;
+    <T, K extends KeysOfType<T, number>>(array: readonly T[], key: K): T | undefined;
+};
 export declare const intersperse: <T>(array: readonly T[], delimiter: T) => T[];
 export declare const zip: <T, R, V>(array: readonly T[], otherArray: readonly R[], transform: (value: T, otherValue: R) => V) => V[];
 export declare const chunked: <T>(array: readonly T[], size: number) => T[][];

package/utility/arrays.lua

@@ -3,6 +3,8 @@ local __TS__New = ____lualib.__TS__New
 local ____exports = {}
 local ____exception = require("exception")
 local IllegalArgumentException = ____exception.IllegalArgumentException
+local ____functions = require("utility.functions")
+local identity = ____functions.identity
 local mathMax = math.max
 local mathMin = math.min
 local select = _G.select
@@ -47,6 +49,14 @@ ____exports.toLuaSet = function(array)
     end
     return result
 end
+____exports.contains = function(array, element)
+    for i = 1, #array do
+        if array[i] == element then
+            return true
+        end
+    end
+    return false
+end
 ____exports.forEach = function(array, consumerOrKey, ...)
     if type(consumerOrKey) == "function" then
         for i = 1, #array do
@@ -120,6 +130,7 @@ ____exports.mapToLuaSet = function(array, transform)
     end
     return result
 end
+____exports.flatten = function(array) return ____exports.flatMap(array, identity) end
 ____exports.flatMap = function(array, transform)
     local result = {}
     local k = 1
@@ -178,9 +189,16 @@ ____exports.associate = function(array, keySelector, valueSelector)
 end
 ____exports.associateBy = function(array, keySelector)
     local result = {}
-    for i = 1, #array do
-        local value = array[i]
-        result[keySelector(value)] = value
+    if type(keySelector) == "function" then
+        for i = 1, #array do
+            local value = array[i]
+            result[keySelector(value)] = value
+        end
+    else
+        for i = 1, #array do
+            local value = array[i]
+            result[value[keySelector]] = value
+        end
     end
     return result
 end
@@ -251,6 +269,30 @@ ____exports.max = function(array)
     end
     return mathMax(table.unpack(array))
 end
+____exports.maxBy = function(array, selector, ...)
+    local result = nil
+    local maxValue = -math.huge
+    if type(selector) == "function" then
+        for i = 1, #array do
+            local element = array[i]
+            local value = selector(element, ...)
+            if value > maxValue then
+                result = element
+                maxValue = value
+            end
+        end
+    else
+        for i = 1, #array do
+            local element = array[i]
+            local value = element[selector]
+            if value > maxValue then
+                result = element
+                maxValue = value
+            end
+        end
+    end
+    return result
+end
 ____exports.intersperse = function(array, delimiter)
     local result = {}
     local length = #array

package/utility/callback-array.d.ts

@@ -0,0 +1,17 @@
+/** @noSelfInFile */
+type Callback = {
+    readonly __callback: unique symbol;
+};
+export type CallbackId = number & {
+    readonly __callbackId: unique symbol;
+};
+export type CallbackArray = {
+    readonly __callbackArray: unique symbol;
+} & Callback[];
+export declare const callbackArray: () => CallbackArray;
+export declare function addCallback<Args extends any[]>(this: void, array: CallbackArray, callback: (...args: Args) => unknown, ...args: Args): CallbackId;
+export declare function clearCallbacks(this: void, array: CallbackArray): void;
+export declare function consumeCallback(this: void, array: CallbackArray, id: CallbackId): void;
+export declare function consumeCallbacks(this: void, array: CallbackArray): void;
+export declare function invokeCallbacks(this: void, array: CallbackArray): void;
+export {};

package/utility/callback-array.lua

@@ -0,0 +1,61 @@
+local ____exports = {}
+local safeCall, tableUnpack
+function ____exports.invokeCallbacks(array)
+    local length = array[1] or 2
+    local i = 2
+    while i ~= length do
+        local callback = array[i]
+        i = i + 1
+        local argsCount = array[i]
+        i = i + 1
+        safeCall(
+            callback,
+            tableUnpack(array, i, i + argsCount - 1)
+        )
+        i = i + argsCount
+    end
+end
+safeCall = warpack.safeCall
+local select = _G.select
+local tableMove = table.move
+tableUnpack = table.unpack
+____exports.callbackArray = function() return {} end
+local function doNothing()
+end
+function ____exports.addCallback(array, callback, ...)
+    local id = array[1] or 2
+    local i = id
+    array[i] = callback
+    local argsCount = select("#", ...)
+    i = i + 1
+    array[i] = argsCount
+    for j = 1, argsCount do
+        i = i + 1
+        array[i] = (select(j, ...))
+    end
+    array[1] = i + 1
+    return id
+end
+function ____exports.clearCallbacks(array)
+    local length = array[1] or 2
+    tableMove(array, length, length + length - 2, 1)
+end
+function ____exports.consumeCallback(array, id)
+    local callback = array[id]
+    array[id] = doNothing
+    id = id + 1
+    local argsCount = array[id]
+    id = id + 1
+    safeCall(
+        callback,
+        tableUnpack(array, id, id + argsCount - 1)
+    )
+end
+function ____exports.consumeCallbacks(array)
+    local length = array[1] or 2
+    ____exports.invokeCallbacks(array)
+    local newLength = array[1] or 2
+    tableMove(array, length, length + newLength - 3, 2)
+    array[1] = newLength - length + 2
+end
+return ____exports

package/utility/functions.d.ts

@@ -3,3 +3,11 @@ export declare const apply: {
     <T, ConsumerParameters extends any[]>(object: T, consumer: (value: T, ...parameters: ConsumerParameters) => void, ...parameters: ConsumerParameters): T;
     <T, ConsumerParameters extends any[], K extends KeysOfType<T, (...parameters: ConsumerParameters) => void>>(object: T, key: K, ...parameters: ConsumerParameters): T;
 };
+export declare const identity: <T>(value: T) => T;
+export declare const firstArgument: <T>(value: T) => T;
+export declare const secondArgument: <T>(_: unknown, value: T) => T;
+export declare const thirdArgument: <T>(_first: unknown, _second: unknown, value: T) => T;
+export declare const increment: (value: number) => number;
+export declare const or: (lhs: boolean, rhs: boolean) => boolean;
+export type Transform<T, R> = (<T, R>(value: T) => R) | KeysOfType<T, R>;
+export declare const transform: <T, R>(object: T, transform: Transform<T, R>) => R;

package/utility/functions.lua

@@ -87,4 +87,17 @@ ____exports.apply = function(object, transform, ...)
     end
     return object
 end
+____exports.identity = function(value) return value end
+____exports.firstArgument = ____exports.identity
+____exports.secondArgument = function(_, value) return value end
+____exports.thirdArgument = function(_first, _second, value) return value end
+____exports.increment = function(value) return value + 1 end
+____exports["or"] = function(lhs, rhs) return lhs or rhs end
+____exports.transform = function(object, transform)
+    if type(transform) == "function" then
+        return transform(object)
+    else
+        return object[transform]
+    end
+end
 return ____exports

package/utility/lazy.d.ts

@@ -0,0 +1,2 @@
+/** @noSelfInFile */
+export declare const lazyRecord: <K extends keyof any, V>(initializer: (key: K) => V) => Readonly<Record<K, V>>;

package/utility/lazy.lua

@@ -0,0 +1,14 @@
+local ____exports = {}
+local rawset = _G.rawset
+local setmetatable = _G.setmetatable
+____exports.lazyRecord = function(initializer)
+    return setmetatable(
+        {},
+        {__index = function(self, key)
+            local value = initializer(key)
+            rawset(self, key, value)
+            return value
+        end}
+    )
+end
+return ____exports

package/utility/linked-map.d.ts

@@ -0,0 +1,26 @@
+/** @noSelfInFile */
+import { ReadonlyLinkedSet } from "./linked-set";
+type IteratorState<K extends AnyNotNil, V> = {
+    n?: K;
+    t: LuaMap<K, K>;
+    v: LuaMap<K, V>;
+};
+type OneSidedTypeGuard = {
+    readonly __oneSidedTypeGuard: unique symbol;
+};
+export interface LinkedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly __linkedSet: unique symbol;
+}
+export declare class LinkedMap<K extends AnyNotNil, V> {
+    private k;
+    private v;
+    get keys(): ReadonlyLinkedSet<K>;
+    get(key: K): V | undefined;
+    getOrPut(key: K, defaultValue: (this: void) => V): V;
+    put(key: K, value: V): void;
+    remove(key: K): boolean;
+    contains(key: AnyNotNil): key is K & OneSidedTypeGuard;
+    get size(): number;
+    protected __pairs(this: LinkedMap<K, V>): LuaIterator<LuaMultiReturn<[K | undefined, V | undefined]>, IteratorState<K, V>>;
+}
+export {};

package/utility/linked-map.lua

@@ -0,0 +1,66 @@
+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 ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local function linkedMapNext(state)
+    local n = state.n
+    state.n = state.t[n]
+    return n, state.v[n]
+end
+____exports.LinkedMap = __TS__Class()
+local LinkedMap = ____exports.LinkedMap
+LinkedMap.name = "LinkedMap"
+function LinkedMap.prototype.____constructor(self)
+    self.k = __TS__New(LinkedSet)
+    self.v = {}
+end
+function LinkedMap.prototype.get(self, key)
+    return self.v[key]
+end
+function LinkedMap.prototype.getOrPut(self, key, defaultValue)
+    local value = self.v[key]
+    if value ~= nil then
+        return value
+    end
+    value = defaultValue()
+    self.k:add(key)
+    self.v[key] = value
+    return value
+end
+function LinkedMap.prototype.put(self, key, value)
+    self.k:add(key)
+    self.v[key] = value
+end
+function LinkedMap.prototype.remove(self, key)
+    if self.k:remove(key) then
+        self.v[key] = nil
+        return true
+    end
+    return false
+end
+function LinkedMap.prototype.contains(self, key)
+    return self.keys:contains(key)
+end
+function LinkedMap.prototype.__pairs(self)
+    return linkedMapNext, {n = self.k.f, t = self.k.n, v = self.v}, nil
+end
+__TS__SetDescriptor(
+    LinkedMap.prototype,
+    "keys",
+    {get = function(self)
+        return self.k
+    end},
+    true
+)
+__TS__SetDescriptor(
+    LinkedMap.prototype,
+    "size",
+    {get = function(self)
+        return self.keys.size
+    end},
+    true
+)
+return ____exports

package/utility/linked-set.d.ts

@@ -1,4 +1,5 @@
 /** @noSelfInFile */
+import { NonEmptyArray, ReadonlyNonEmptyArray } from "./types";
 type IteratorState<T extends AnyNotNil> = {
     t: LuaMap<T, T>;
     n?: T;
@@ -18,6 +19,11 @@ export interface ReadonlyLinkedSet<T extends AnyNotNil> extends LuaPairsKeyItera
     toArray(): T[];
     sumOf(selector: ((value: T) => number) | KeysOfType<T, number>): number;
 }
+export interface ReadonlyNonEmptyLinkedSet<T extends AnyNotNil> extends ReadonlyLinkedSet<T> {
+    first(): T;
+    last(): T;
+    toArray(): NonEmptyArray<T>;
+}
 export interface LinkedSet<T extends AnyNotNil> extends LuaPairsKeyIterable<T> {
     readonly __linkedSet: unique symbol;
 }
@@ -30,6 +36,7 @@ export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet
     copyOf(): LinkedSet<T>;
     first(): T | undefined;
     last(): T | undefined;
+    pop(): T | undefined;
     next(key: T): T | undefined;
     previous(key: T): T | undefined;
     add(key: T): boolean;
@@ -44,6 +51,10 @@ export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet
     protected __pairs(this: LinkedSet<T>): LuaIterator<T | undefined, IteratorState<T>>;
 }
 export declare const emptyLinkedSet: <T extends AnyNotNil>() => ReadonlyLinkedSet<T>;
-export declare const linkedSetOf: <T extends AnyNotNil>(...elements: readonly T[]) => LinkedSet<T>;
-export declare const linkedSetOfNotNull: <T extends AnyNotNil>(...elements: readonly (T | undefined | null)[]) => LinkedSet<T>;
+export declare const mutableLinkedSet: <T extends AnyNotNil>() => LinkedSet<T>;
+export declare const mutableLinkedSetOf: <T extends AnyNotNil>(...elements: ReadonlyArray<T>) => LinkedSet<T>;
+export declare const mutableLinkedSetOfNotNull: <T extends AnyNotNil>(...elements: readonly (T | undefined | null)[]) => LinkedSet<T>;
+export declare const linkedSetOf: <T extends AnyNotNil>(...elements: ReadonlyArray<T>) => ReadonlyLinkedSet<T>;
+export declare const linkedSetOfNotNull: <T extends AnyNotNil>(...elements: ReadonlyArray<T>) => ReadonlyLinkedSet<T>;
+export declare const nonEmptyLinkedSetOf: <T extends AnyNotNil>(...elements: ReadonlyNonEmptyArray<T>) => ReadonlyNonEmptyLinkedSet<T>;
 export {};

package/utility/linked-set.lua

@@ -42,6 +42,23 @@ end
 function LinkedSet.prototype.last(self)
     return self.l
 end
+function LinkedSet.prototype.pop(self)
+    local f = self.f
+    if f == nil then
+        return nil
+    end
+    local n = self.n
+    local next = n[f]
+    n[f] = nil
+    self.f = next
+    if next ~= nil then
+        self.p[next] = nil
+    else
+        self.l = nil
+    end
+    self.s = self.s - 1
+    return f
+end
 function LinkedSet.prototype.next(self, key)
     return self.n[key]
 end
@@ -107,8 +124,9 @@ function LinkedSet.prototype.forEach(self, action, ...)
     local n = self.n
     local c = self.f
     while c ~= nil do
+        local next = n[c]
         action(c, ...)
-        c = n[c]
+        c = next
     end
 end
 function LinkedSet.prototype.toArray(self)
@@ -177,14 +195,17 @@ local EMPTY_LINKED_SET = __TS__New(EmptyLinkedSet)
 ____exports.emptyLinkedSet = function()
     return EMPTY_LINKED_SET
 end
-____exports.linkedSetOf = function(...)
+____exports.mutableLinkedSet = function()
+    return __TS__New(____exports.LinkedSet)
+end
+____exports.mutableLinkedSetOf = function(...)
     local linkedSet = __TS__New(____exports.LinkedSet)
     for i = 1, select("#", ...) do
         linkedSet:add((select(i, ...)))
     end
     return linkedSet
 end
-____exports.linkedSetOfNotNull = function(...)
+____exports.mutableLinkedSetOfNotNull = function(...)
     local linkedSet = __TS__New(____exports.LinkedSet)
     for i = 1, select("#", ...) do
         local element = (select(i, ...))
@@ -194,4 +215,7 @@ ____exports.linkedSetOfNotNull = function(...)
     end
     return linkedSet
 end
+____exports.linkedSetOf = function(...) return ____exports.mutableLinkedSetOf(...) end
+____exports.linkedSetOfNotNull = function(...) return ____exports.mutableLinkedSetOfNotNull(...) end
+____exports.nonEmptyLinkedSetOf = function(...) return ____exports.linkedSetOf(...) end
 return ____exports

package/utility/lua-maps.d.ts

@@ -1,5 +1,18 @@
 /** @noSelfInFile */
 import { Flatten, TupleOf } from "./types";
+export declare const emptyLuaMap: <K extends AnyNotNil, V>() => ReadonlyLuaMap<K, V>;
+export declare const mutableLuaMap: <K extends AnyNotNil, V>() => LuaMap<K, V>;
+export declare const mutableWeakLuaMap: <K extends AnyNotNil, V>() => LuaMap<K, V>;
 export declare const luaMapOf: <K extends AnyNotNil, V>(...pairs: Flatten<TupleOf<[K, V], 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40>>) => 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>;
+export declare const luaMapInvert: <K extends AnyNotNil, V extends AnyNotNil>(luaMap: ReadonlyLuaMap<K, V | undefined | null>) => LuaMap<V, K>;
+export declare const toLuaMap: <K extends PropertyKey, V>(record: Record<K, V>) => LuaMap<K, V>;
+export declare const flattenKeys: <K extends AnyNotNil, V>(luaMap: ReadonlyLuaMap<readonly K[], V> | ReadonlyLuaMap<K[], V>) => LuaMap<K, V>;
+export declare const mapKeys: {
+    <K1 extends AnyNotNil, K2 extends AnyNotNil, V>(luaMap: ReadonlyLuaMap<K1, V>, transform: (value: K1) => K2): LuaMap<K2, V>;
+    <K1 extends AnyNotNil, K2 extends keyof K1, V>(luaMap: ReadonlyLuaMap<K1, V>, key: K2): K1[K2] extends AnyNotNil ? LuaMap<K1[K2], V> : never;
+};
+export declare const mapValues: {
+    <K extends AnyNotNil, V1, V2>(luaMap: ReadonlyLuaMap<K, V1>, transform: (value: V1) => V2): LuaMap<K, V2>;
+    <K extends AnyNotNil, V1, V2 extends keyof V1>(luaMap: ReadonlyLuaMap<K, V1>, key: V2): LuaMap<K, V1[V2]>;
+};
+export declare const getOrPut: <K extends AnyNotNil, V>(luaMap: LuaMap<K, V>, key: K, defaultValue: () => V) => V;

package/utility/lua-maps.lua

@@ -1,5 +1,17 @@
 local ____exports = {}
 local select = _G.select
+local setmetatable = _G.setmetatable
+local weakKeysMetatable = {__mode = "k"}
+local EMPTY_LUA_MAP = {}
+____exports.emptyLuaMap = function()
+    return EMPTY_LUA_MAP
+end
+____exports.mutableLuaMap = function()
+    return {}
+end
+____exports.mutableWeakLuaMap = function()
+    return setmetatable({}, weakKeysMetatable)
+end
 ____exports.luaMapOf = function(...)
     local luaMap = {}
     for i = 1, select("#", ...), 2 do
@@ -15,11 +27,50 @@ ____exports.luaMapInvert = function(luaMap)
     end
     return invertLuaMap
 end
+____exports.toLuaMap = function(record)
+    return record
+end
+____exports.flattenKeys = function(luaMap)
+    local result = {}
+    for keys, value in pairs(luaMap) do
+        for ____, key in ipairs(keys) do
+            result[key] = value
+        end
+    end
+    return result
+end
+____exports.mapKeys = function(luaMap, transform)
+    local result = {}
+    if type(transform) == "function" then
+        for key, value in pairs(luaMap) do
+            result[transform(key)] = value
+        end
+    else
+        for key, value in pairs(luaMap) do
+            result[key[transform]] = value
+        end
+    end
+    return result
+end
 ____exports.mapValues = function(luaMap, transform)
     local result = {}
-    for key, value in pairs(luaMap) do
-        result[key] = transform(value)
+    if type(transform) == "function" then
+        for key, value in pairs(luaMap) do
+            result[key] = transform(value)
+        end
+    else
+        for key, value in pairs(luaMap) do
+            result[key] = value[transform]
+        end
     end
     return result
 end
+____exports.getOrPut = function(luaMap, key, defaultValue)
+    local value = luaMap[key]
+    if value == nil then
+        value = defaultValue()
+        luaMap[key] = value
+    end
+    return value
+end
 return ____exports

package/utility/lua-sets.d.ts

@@ -1,4 +1,6 @@
 /** @noSelfInFile */
+export declare const emptyLuaSet: <T extends AnyNotNil>() => ReadonlyLuaSet<T>;
+export declare const mutableLuaSet: <T extends AnyNotNil>() => LuaSet<T>;
 export declare const luaSetOf: <T extends AnyNotNil>(...elements: readonly T[]) => LuaSet<T>;
 export declare const luaSetOfNotNull: <T extends AnyNotNil>(...elements: readonly (T | undefined | null)[]) => LuaSet<T>;
 export declare const luaSetIntersection: <T extends AnyNotNil>(firstLuaSet: ReadonlyLuaSet<T>, secondLuaSet: ReadonlyLuaSet<T>) => LuaSet<T>;

package/utility/lua-sets.lua

@@ -1,5 +1,12 @@
 local ____exports = {}
 local select = _G.select
+local EMPTY_LUA_SET = {}
+____exports.emptyLuaSet = function()
+    return EMPTY_LUA_SET
+end
+____exports.mutableLuaSet = function()
+    return {}
+end
 ____exports.luaSetOf = function(...)
     local luaSet = {}
     for i = 1, select("#", ...) do

package/utility/records.lua

@@ -1,9 +1,28 @@
 local ____exports = {}
+local ____pairs = _G.pairs
+local tableSort = table.sort
 ____exports.invertRecord = function(record)
     local invertRecord = {}
-    for key, value in pairs(record) do
+    for key, value in ____pairs(record) do
         invertRecord[value] = key
     end
     return invertRecord
 end
+local sortedKeysInternal = {}
+local lastSortedKeysLength = 0
+---
+-- @internal For use by internal systems only.
+____exports.sortedKeysUnnested = function(record)
+    local length = 0
+    for key in ____pairs(record) do
+        length = length + 1
+        sortedKeysInternal[length] = key
+    end
+    for i = length + 1, lastSortedKeysLength do
+        sortedKeysInternal[i] = nil
+    end
+    lastSortedKeysLength = length
+    tableSort(sortedKeysInternal)
+    return sortedKeysInternal
+end
 return ____exports

package/utility/reflection.lua

@@ -5,21 +5,25 @@ local checkNotNull = ____preconditions.checkNotNull
 -- @internal For use by internal systems only.
 ____exports.implementReadonlyNumberIndexSupplier = function(clazz, supplier)
     local metatable = checkNotNull(getmetatable(clazz))
-    local originalIndex = checkNotNull(metatable.__index)
+    local originalIndex = checkNotNull(rawget(metatable, "__index"))
     local memoizedValueByKey = {}
-    metatable.__index = setmetatable(
-        memoizedValueByKey,
-        {__index = function(self, key)
+    rawset(
+        metatable,
+        "__index",
+        function(self, key)
             if type(key) == "number" then
-                local value = supplier(key)
-                memoizedValueByKey[key] = value
+                local value = memoizedValueByKey[key]
+                if value == nil then
+                    value = supplier(key)
+                    memoizedValueByKey[key] = value
+                end
                 return value
             end
             if type(originalIndex) == "function" then
                 return originalIndex(self, key)
             end
             return originalIndex[key]
-        end}
+        end
     )
 end
 ____exports.getClass = function(object)

package/utility/types.d.ts

@@ -2,6 +2,7 @@
 export type AnyNonNullable = {};
 export type IsExactlyAny<T> = boolean extends (T extends never ? true : false) ? true : false;
 export type NonEmptyArray<T> = [T, ...T[]];
+export type ReadonlyNonEmptyArray<T> = readonly [T, ...T[]];
 export type InvertRecordType<T extends Record<PropertyKey, PropertyKey | null | undefined>> = {
     [P in keyof T as NonNullable<T[P]>]: P;
 };
@@ -36,4 +37,7 @@ export type Flatten<T extends readonly any[], A extends readonly any[] = []> = T
 export type Prohibit<T, K extends keyof any> = T & {
     [P in K]?: never;
 };
+type TupleSplit<T, N extends number, O extends readonly any[] = readonly []> = O["length"] extends N ? [O, T] : T extends readonly [infer F, ...infer R] ? TupleSplit<readonly [...R], N, readonly [...O, F]> : [O, T];
+export type TakeFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[0];
+export type SkipFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[1];
 export {};

package/core/mapbounds.d.ts

@@ -1,8 +0,0 @@
-/** @noSelfInFile */
-import { Rect } from "./types/rect";
-import { Region } from "./types/region";
-export declare const boundRect: Rect;
-export declare const boundRegion: Region;
-export declare const boundMin: Readonly<Vec2>;
-export declare const boundMax: Readonly<Vec2>;
-export declare const boundCenter: Readonly<Vec2>;

package/core/mapbounds.lua

@@ -1,12 +0,0 @@
-local ____exports = {}
-local ____rect = require("core.types.rect")
-local Rect = ____rect.Rect
-local ____region = require("core.types.region")
-local Region = ____region.Region
-____exports.boundRect = Rect:of(GetWorldBounds())
-____exports.boundRegion = Region:create()
-____exports.boundRegion:addRect(____exports.boundRect)
-____exports.boundMin = vec2(____exports.boundRect.minX, ____exports.boundRect.minY)
-____exports.boundMax = vec2(____exports.boundRect.maxX, ____exports.boundRect.maxY)
-____exports.boundCenter = (____exports.boundMin + ____exports.boundMax) * 0.5
-return ____exports