warscript 0.0.1-dev.ea69747 → 0.0.1-dev.eb92d79

package/property.lua

@@ -0,0 +1,374 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local savePropertyValues
+local ____binaryreader = require("binaryreader")
+local BinaryReader = ____binaryreader.BinaryReader
+local ____binarywriter = require("binarywriter")
+local BinaryWriter = ____binarywriter.BinaryWriter
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local ____event = require("event")
+local Event = ____event.Event
+local file = require("file")
+local ____network = require("network")
+local synchronize = ____network.synchronize
+local base64 = require("utility.base64")
+local lzw = require("utility.lzw")
+local ____preconditions = require("utility.preconditions")
+local ____require = ____preconditions.require
+local invoke = Event.invoke
+____exports.PersistentPropertiesConfig = __TS__Class()
+local PersistentPropertiesConfig = ____exports.PersistentPropertiesConfig
+PersistentPropertiesConfig.name = "PersistentPropertiesConfig"
+function PersistentPropertiesConfig.prototype.____constructor(self)
+end
+PersistentPropertiesConfig.defaultFileName = ""
+____exports.Property = __TS__Class()
+local Property = ____exports.Property
+Property.name = "Property"
+function Property.prototype.____constructor(self, defaultValue)
+    self.valueChangeEvent = __TS__New(Event)
+    self[0] = defaultValue
+    self[1] = defaultValue
+end
+function Property.prototype.reset(self)
+    if self[2] then
+        self[2] = nil
+        local defaultValue = self[0]
+        local oldValue = self[1]
+        if defaultValue ~= oldValue then
+            self[1] = defaultValue
+            invoke(self.valueChangeEvent, defaultValue, oldValue)
+        end
+        return true
+    end
+    return false
+end
+function Property.prototype.set(self, value)
+    self[2] = true
+    local oldValue = self[1]
+    self[1] = value
+    if value ~= oldValue then
+        invoke(self.valueChangeEvent, value, oldValue)
+        return true
+    end
+    return false
+end
+function Property.prototype.get(self)
+    return self[1]
+end
+__TS__SetDescriptor(
+    Property.prototype,
+    "defaultValue",
+    {
+        get = function(self)
+            return self[0]
+        end,
+        set = function(self, defaultValue)
+            local oldDefaultValue = self[0]
+            if defaultValue ~= oldDefaultValue then
+                self[0] = defaultValue
+                if not self[2] then
+                    self[1] = defaultValue
+                    invoke(self.valueChangeEvent, defaultValue, oldDefaultValue)
+                end
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Property.prototype,
+    "value",
+    {
+        get = function(self)
+            return self:get()
+        end,
+        set = function(self, value)
+            self:set(value)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Property.prototype,
+    "isChanged",
+    {get = function(self)
+        return self[2] == true
+    end},
+    true
+)
+____exports.PlayerProperty = __TS__Class()
+local PlayerProperty = ____exports.PlayerProperty
+PlayerProperty.name = "PlayerProperty"
+function PlayerProperty.prototype.____constructor(self, defaultValue)
+    self.valueChangeEvent = __TS__New(Event)
+    self[0] = defaultValue
+    self[1] = {}
+    self[2] = {}
+end
+function PlayerProperty.prototype.isChanged(self, player)
+    return self[2][player] ~= nil
+end
+function PlayerProperty.prototype.reset(self, player)
+    if self[2][player] ~= nil then
+        self[2][player] = nil
+        local initialValue = self[0]
+        local oldValue = self[1][player]
+        self[1][player] = nil
+        if initialValue ~= oldValue then
+            invoke(self.valueChangeEvent, player, initialValue, oldValue)
+        end
+        return true
+    end
+    return false
+end
+function PlayerProperty.prototype.set(self, player, value)
+    self[2][player] = true
+    local oldValue = self[1][player]
+    self[1][player] = value
+    if value ~= oldValue then
+        invoke(self.valueChangeEvent, player, value, oldValue)
+        return true
+    end
+    return false
+end
+function PlayerProperty.prototype.get(self, player)
+    local ____table_PlayerPropertyPropertyKey_IS_CHANGED_BY_PLAYER_has_result_0
+    if self[2][player] ~= nil then
+        ____table_PlayerPropertyPropertyKey_IS_CHANGED_BY_PLAYER_has_result_0 = self[1][player]
+    else
+        ____table_PlayerPropertyPropertyKey_IS_CHANGED_BY_PLAYER_has_result_0 = self[0]
+    end
+    return ____table_PlayerPropertyPropertyKey_IS_CHANGED_BY_PLAYER_has_result_0
+end
+local NULL_VALUE = {}
+local loadedValueById
+local loadedValueByIdByPlayer = {}
+local localValueById = {}
+local persistentPropertyById = {}
+local persistentPlayerPropertyById = {}
+____exports.PersistentProperty = __TS__Class()
+local PersistentProperty = ____exports.PersistentProperty
+PersistentProperty.name = "PersistentProperty"
+__TS__ClassExtends(PersistentProperty, ____exports.Property)
+function PersistentProperty.prototype.____constructor(self, id, defaultValue, valueChangeEventListener)
+    PersistentProperty.____super.prototype.____constructor(self, defaultValue)
+    self.id = id
+    ____require(not (persistentPropertyById[id] ~= nil) and not (persistentPlayerPropertyById[id] ~= nil))
+    persistentPropertyById[id] = self
+    if valueChangeEventListener ~= nil then
+        self.valueChangeEvent:addListener(valueChangeEventListener)
+    end
+    local value = loadedValueById and loadedValueById[id]
+    if value ~= nil then
+        local ____self_set_4 = self.set
+        local ____temp_3
+        if value == NULL_VALUE then
+            ____temp_3 = nil
+        else
+            ____temp_3 = value
+        end
+        ____self_set_4(self, ____temp_3)
+    end
+end
+function PersistentProperty.prototype.reset(self)
+    if PersistentProperty.____super.prototype.reset(self) then
+        localValueById[self.id] = nil
+        savePropertyValues()
+        return true
+    end
+    return false
+end
+function PersistentProperty.prototype.set(self, value)
+    if PersistentProperty.____super.prototype.set(self, value) then
+        localValueById[self.id] = value == nil and NULL_VALUE or value
+        savePropertyValues()
+        return true
+    end
+    return false
+end
+____exports.PersistentPlayerProperty = __TS__Class()
+local PersistentPlayerProperty = ____exports.PersistentPlayerProperty
+PersistentPlayerProperty.name = "PersistentPlayerProperty"
+__TS__ClassExtends(PersistentPlayerProperty, ____exports.PlayerProperty)
+function PersistentPlayerProperty.prototype.____constructor(self, id, initialValue, valueChangeEventListener)
+    PersistentPlayerProperty.____super.prototype.____constructor(self, initialValue)
+    self.id = id
+    ____require(not (persistentPropertyById[id] ~= nil) and not (persistentPlayerPropertyById[id] ~= nil))
+    persistentPlayerPropertyById[id] = self
+    if valueChangeEventListener ~= nil then
+        self.valueChangeEvent:addListener(valueChangeEventListener)
+    end
+    for ____, player in ipairs(Player.all) do
+        local ____opt_5 = loadedValueByIdByPlayer and loadedValueByIdByPlayer[player]
+        local value = ____opt_5 and ____opt_5[id]
+        if value ~= nil then
+            local ____self_set_10 = self.set
+            local ____temp_9
+            if value == NULL_VALUE then
+                ____temp_9 = nil
+            else
+                ____temp_9 = value
+            end
+            ____self_set_10(self, player, ____temp_9)
+        end
+    end
+end
+function PersistentPlayerProperty.prototype.reset(self, player)
+    if PersistentPlayerProperty.____super.prototype.reset(self, player) then
+        if player.isLocal then
+            localValueById[self.id] = nil
+        end
+        savePropertyValues(player)
+        return true
+    end
+    return false
+end
+function PersistentPlayerProperty.prototype.set(self, player, value)
+    if PersistentPlayerProperty.____super.prototype.set(self, player, value) then
+        if player.isLocal then
+            localValueById[self.id] = value
+        end
+        savePropertyValues(player)
+        return true
+    end
+    return false
+end
+savePropertyValues = function(player)
+    if player ~= nil and not player.isLocal or loadedValueById == nil or loadedValueByIdByPlayer[Player["local"]] == nil then
+        return
+    end
+    local writer = __TS__New(BinaryWriter)
+    writer:writeUInt32(0)
+    local size = 0
+    for ____ in pairs(localValueById) do
+        size = size + 1
+    end
+    writer:writeUInt32(size)
+    for id, value in pairs(localValueById) do
+        writer:writeInt32(id)
+        if value == NULL_VALUE then
+            writer:writeUInt8(0)
+        elseif value == false then
+            writer:writeUInt8(1)
+        elseif value == true then
+            writer:writeUInt8(2)
+        elseif type(value) == "number" then
+            if math.type(value) == "integer" then
+                writer:writeUInt8(3)
+                writer:writeInt32(value)
+            else
+                writer:writeUInt8(4)
+                writer:writeFloat(value)
+            end
+        else
+            writer:writeUInt8(5)
+            writer:writeUInt32(#value)
+            writer:writeBytes(value)
+        end
+    end
+    file.write(
+        ____exports.PersistentPropertiesConfig.defaultFileName,
+        base64.encode(lzw.compress(tostring(writer)))
+    )
+end
+local function loadPropertyValues(fileData, player)
+    do
+        local function ____catch(_)
+            return true, {}
+        end
+        local ____try, ____hasReturned, ____returnValue = pcall(function()
+            local valueById = {}
+            local reader = __TS__New(
+                BinaryReader,
+                lzw.decompress(base64.decode(fileData))
+            )
+            reader:readUInt32()
+            local size = reader:readUInt32()
+            for _ = 1, size do
+                local id = reader:readInt32()
+                local dataType = reader:readUInt8()
+                if dataType == 0 then
+                    valueById[id] = NULL_VALUE
+                elseif dataType == 1 then
+                    valueById[id] = false
+                elseif dataType == 2 then
+                    valueById[id] = true
+                elseif dataType == 3 then
+                    valueById[id] = reader:readInt32()
+                elseif dataType == 4 then
+                    valueById[id] = reader:readFloat()
+                elseif dataType == 5 then
+                    valueById[id] = reader:readBytes(reader:readUInt32())
+                end
+            end
+            for id, value in pairs(valueById) do
+                local persistentProperty = persistentPropertyById[id]
+                if persistentProperty ~= nil then
+                    if not persistentProperty.isChanged then
+                        local ____persistentProperty_set_12 = persistentProperty.set
+                        local ____temp_11
+                        if value == NULL_VALUE then
+                            ____temp_11 = nil
+                        else
+                            ____temp_11 = value
+                        end
+                        ____persistentProperty_set_12(persistentProperty, ____temp_11)
+                    end
+                elseif player ~= nil then
+                    local persistentPlayerProperty = persistentPlayerPropertyById[id]
+                    if persistentPlayerProperty ~= nil then
+                        if not persistentPlayerProperty:isChanged(player) then
+                            local ____persistentPlayerProperty_set_15 = persistentPlayerProperty.set
+                            local ____player_14 = player
+                            local ____temp_13
+                            if value == NULL_VALUE then
+                                ____temp_13 = nil
+                            else
+                                ____temp_13 = value
+                            end
+                            ____persistentPlayerProperty_set_15(persistentPlayerProperty, ____player_14, ____temp_13)
+                        end
+                    elseif player.isLocal then
+                        localValueById[id] = value
+                    end
+                else
+                    localValueById[id] = value
+                end
+            end
+            return true, valueById
+        end)
+        if not ____try then
+            ____hasReturned, ____returnValue = ____catch(____hasReturned)
+        end
+        if ____hasReturned then
+            return ____returnValue
+        end
+    end
+end
+Timer:run(function()
+    local data = file.read(____exports.PersistentPropertiesConfig.defaultFileName) or ""
+    loadedValueById = loadPropertyValues(data)
+    for ____, player in ipairs(Player.all) do
+        local ____self_16 = synchronize(player, data)
+        ____self_16["then"](
+            ____self_16,
+            function(____, synchronizedData)
+                loadedValueByIdByPlayer[player] = loadPropertyValues(synchronizedData, player)
+                savePropertyValues(player)
+            end,
+            function()
+                loadedValueByIdByPlayer[player] = {}
+                savePropertyValues(player)
+            end
+        )
+    end
+end)
+return ____exports

package/string.d.ts

@@ -59,6 +59,22 @@ declare global {
         function toNumber(string: string): number;
     }
 }
+declare global {
+    namespace string {
+        /**
+         * Returns the index within the string of the first occurrence of the specified substring, starting from the specified `startIndex`,
+         * or -1 if the string does not contain such substring.
+         */
+        function indexOf(string: string, substring: string, startIndex?: number): number;
+    }
+    interface String {
+        /**
+         * Returns the index within this string of the first occurrence of the specified substring, starting from the specified `startIndex`,
+         * or -1 if the string does not contain such substring.
+         */
+        indexOf(substring: string, startIndex?: number): number;
+    }
+}
 declare global {
     interface String {
         /**
@@ -103,4 +119,18 @@ declare global {
         function isNotBlank(string: string): boolean;
     }
 }
+declare global {
+    namespace string {
+        /**
+         * Returns the number of characters matching the given predicate.
+         */
+        function count(string: string, predicate: (char: string) => boolean): number;
+    }
+    interface String {
+        /**
+         * Returns the number of characters matching the given predicate.
+         */
+        count(predicate: (char: string) => boolean): number;
+    }
+}
 export {};

package/string.lua

@@ -2,6 +2,7 @@ local ____exports = {}
 local ____error = _G.error
 local tonumber = _G.tonumber
 local match = string.match
+local find = string.find
 local sub = string.sub
 _G.string.removePrefix = function(____string, prefix)
     local prefixLength = #prefix
@@ -17,6 +18,10 @@ end
 _G.string.toNumber = function(____string)
     return tonumber(____string) or ____error(("'" .. ____string) .. "' is not a valid representation of a number.")
 end
+_G.string.indexOf = function(____string, substring, startIndex)
+    local index = find(____string, substring, (startIndex or 0) + 1, true)
+    return (index or 0) - 1
+end
 _G.string.indexOfLast = function(____string, predicate)
     for i = #____string, 1, -1 do
         if predicate(sub(____string, i, i)) then
@@ -31,4 +36,13 @@ end
 _G.string.isNotBlank = function(____string)
     return (match(____string, "^%s*$")) == nil
 end
+_G.string.count = function(____string, predicate)
+    local result = 0
+    for i = 1, #____string do
+        if predicate(sub(____string, i, i)) then
+            result = result + 1
+        end
+    end
+    return result
+end
 return ____exports

package/util/stream.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="@typescript-to-lua/language-extensions" />
 /** @noSelfInFile */
 export interface Stream<T> {
     toArray(): T[];

package/utility/arrays.d.ts

@@ -1,12 +1,11 @@
-/// <reference types="@typescript-to-lua/language-extensions" />
 /** @noSelfInFile */
 import { TupleOf } from "./types";
-export declare const EMPTY_ARRAY: readonly any[];
+export declare const emptyArray: <T>() => readonly T[];
 export declare const joinToString: <T>(array: readonly T[], separator: string, transform?: (element: T) => string) => string;
-export declare const arrayOfNotNull: <T>(...elements: readonly (T | null | undefined)[]) => 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 forEach: <T, Args extends any[]>(array: readonly T[], consumerOrKey: KeysOfType<T, (this: T, ...args: Args) => void> | ((value: T, ...args: Args) => void), ...args: Args) => void;
+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;
     <T>(array: readonly T[], key: KeysOfType<T, boolean>): boolean;
@@ -45,7 +44,7 @@ export declare const max: (array: readonly number[]) => number;
 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[][];
-export declare const sortBy: <T, R>(array: T[], selector: KeysOfType<T, R> | ((value: T) => R)) => void;
+export declare const sortBy: <T, R>(array: T[], selector: ((value: T) => R) | KeysOfType<T, R>) => void;
 export declare const sortedBy: {
     <T, R>(array: readonly T[], selector: (value: T) => R): T[];
     <T, K extends keyof T>(array: readonly T[], key: K): T[];

package/utility/arrays.lua

@@ -8,7 +8,10 @@ local mathMin = math.min
 local select = _G.select
 local tableConcat = table.concat
 local tableSort = table.sort
-____exports.EMPTY_ARRAY = {}
+local EMPTY_ARRAY = {}
+____exports.emptyArray = function()
+    return EMPTY_ARRAY
+end
 ____exports.joinToString = function(array, separator, transform)
     if transform == nil then
         transform = tostring

package/utility/bit-set.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="@warscript/language-extensions" />
-/// <reference types="@typescript-to-lua/language-extensions" />
 /** @noSelfInFile */
 interface IBitSet<T extends number> {
     readonly has: LuaBitwiseAndEqualsRightMethod<T>;

package/utility/linked-set.d.ts

@@ -1,13 +1,33 @@
-/// <reference types="@typescript-to-lua/language-extensions" />
 /** @noSelfInFile */
+import { NonEmptyArray, ReadonlyNonEmptyArray } from "./types";
 type IteratorState<T extends AnyNotNil> = {
     t: LuaMap<T, T>;
     n?: T;
 };
-export interface LinkedSet<T> extends LuaPairsKeyIterable<T> {
-    readonly __linkedHashSet: unique symbol;
+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 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;
 }
-export declare class LinkedSet<T extends AnyNotNil> {
+export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet<T> {
     private n;
     private p;
     private f?;
@@ -20,9 +40,7 @@ export declare class LinkedSet<T extends AnyNotNil> {
     previous(key: T): T | undefined;
     add(key: T): boolean;
     remove(key: T): boolean;
-    contains(key: AnyNotNil): key is T & {
-        readonly __oneSidedTypeGuard: unique symbol;
-    };
+    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;
@@ -31,6 +49,10 @@ export declare class LinkedSet<T extends AnyNotNil> {
     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 declare const emptyLinkedSet: <T extends AnyNotNil>() => ReadonlyLinkedSet<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

@@ -2,9 +2,12 @@ local ____lualib = require("lualib_bundle")
 local __TS__Class = ____lualib.__TS__Class
 local __TS__New = ____lualib.__TS__New
 local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
 local ____exports = {}
 local ____arrays = require("utility.arrays")
 local sortBy = ____arrays.sortBy
+local ____exception = require("exception")
+local UnsupportedOperationException = ____exception.UnsupportedOperationException
 local function linkedSetNext(state)
     local n = state.n
     state.n = state.t[n]
@@ -161,14 +164,27 @@ __TS__SetDescriptor(
     end},
     true
 )
-____exports.linkedSetOf = function(...)
+local EmptyLinkedSet = __TS__Class()
+EmptyLinkedSet.name = "EmptyLinkedSet"
+__TS__ClassExtends(EmptyLinkedSet, ____exports.LinkedSet)
+function EmptyLinkedSet.prototype.add(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+local EMPTY_LINKED_SET = __TS__New(EmptyLinkedSet)
+____exports.emptyLinkedSet = function()
+    return EMPTY_LINKED_SET
+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, ...))
@@ -178,4 +194,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,6 +1,5 @@
-/// <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 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>;

package/utility/lua-sets.d.ts

@@ -1,6 +1,5 @@
-/// <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 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>;
 export declare const luaSetContainsAnyOf: <T extends AnyNotNil>(luaSet: ReadonlyLuaSet<T>, ...elements: readonly T[]) => boolean;

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;
 };
@@ -12,14 +13,14 @@ export type ValueOf<T> = T[keyof T];
 export type EntryOf<T> = ValueOf<{
     [K in keyof T]: [K, T[K]];
 }>;
-export type MutableKeys<T extends object> = {
+export type MutableKeys<T extends object> = keyof T & {
     [P in keyof T]-?: IfEquals<{
         [Q in P]: T[P];
     }, {
         -readonly [Q in P]: T[P];
     }, P>;
 }[keyof T];
-export type ReadonlyKeys<T extends object> = {
+export type ReadonlyKeys<T extends object> = keyof T & {
     [P in keyof T]-?: IfEquals<{
         [Q in P]: T[P];
     }, {

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