warscript 0.0.1-dev.9af2d1a → 0.0.1-dev.9bcb501

package/operation.lua

@@ -22,10 +22,7 @@ OperationMonitor.name = "OperationMonitor"
 __TS__ClassExtends(OperationMonitor, __TS__Promise)
 function OperationMonitor.prototype.____constructor(self, operation, ...)
     local args = {...}
-    __TS__Promise.prototype.____constructor(
-        self,
-        table.unpack(args)
-    )
+    __TS__Promise.prototype.____constructor(self, ...)
     self.o = operation
 end
 function OperationMonitor.prototype.cancel(self)
@@ -38,9 +35,10 @@ local Operation = ____exports.Operation
 Operation.name = "Operation"
 function Operation.prototype.____constructor(self)
     self.started = false
+    self.settled = false
+    self.canceled = false
     self.progress = 0
     self.maximum = 0
-    self.isCanceled = false
 end
 function Operation.prototype.execute(self)
     if self.started then
@@ -58,6 +56,12 @@ function Operation.prototype.execute(self)
                 local result
                 local progress = self.progress
                 local ____try = __TS__AsyncAwaiter(function()
+                    if self.canceled then
+                        error(
+                            __TS__New(CancellationException),
+                            0
+                        )
+                    end
                     local maximum = __TS__Await(self:estimate())
                     self.maximum = maximum
                     if maximum ~= 0 then
@@ -68,20 +72,19 @@ function Operation.prototype.execute(self)
                     end
                     repeat
                         do
-                            if self.isCanceled then
-                                local reason = __TS__New(CancellationException)
-                                reject(nil, reason)
-                                local onFailure = ____rawget(self, "onFailure")
-                                if onFailure ~= nil then
-                                    Event.invoke(onFailure, self, reason)
-                                end
-                                local onComplete = ____rawget(self, "onComplete")
-                                if onComplete ~= nil then
-                                    Event.invoke(onComplete, self, false, reason)
-                                end
-                                return ____awaiter_resolve(nil)
+                            if self.canceled then
+                                error(
+                                    __TS__New(CancellationException),
+                                    0
+                                )
                             end
                             result = __TS__Await(self:work())
+                            if self.canceled then
+                                error(
+                                    __TS__New(CancellationException),
+                                    0
+                                )
+                            end
                             if self.progress ~= progress or self.maximum ~= maximum then
                                 progress = self.progress
                                 maximum = self.maximum
@@ -96,6 +99,7 @@ function Operation.prototype.execute(self)
                 __TS__Await(____try.catch(
                     ____try,
                     function(____, reason)
+                        self.settled = true
                         reject(nil, reason)
                         local onFailure = ____rawget(self, "onFailure")
                         if onFailure ~= nil then
@@ -108,6 +112,7 @@ function Operation.prototype.execute(self)
                         return ____awaiter_resolve(nil)
                     end
                 ))
+                self.settled = true
                 resolve(nil, result)
                 local onSuccess = ____rawget(self, "onSuccess")
                 if onSuccess ~= nil then
@@ -122,12 +127,27 @@ function Operation.prototype.execute(self)
     )
 end
 function Operation.prototype.cancel(self)
+    if self.canceled then
+        return true
+    end
+    if self.settled then
+        return false
+    end
+    self.canceled = true
     if self:doCancel() then
-        self.isCanceled = true
         return true
     end
+    self.canceled = false
     return false
 end
+__TS__SetDescriptor(
+    Operation.prototype,
+    "isCanceled",
+    {get = function(self)
+        return self.canceled
+    end},
+    true
+)
 __TS__SetDescriptor(
     Operation.prototype,
     "isStarted",

package/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package",
     "name": "warscript",
-    "version": "0.0.1-dev.9af2d1a",
+    "version": "0.0.1-dev.9bcb501",
     "description": "A typescript library for Warcraft III using Warpack.",
     "keywords": [
         "warcraft",
@@ -13,31 +13,11 @@
         "type": "git",
         "url": "git+https://github.com/rhazarian/warscript.git"
     },
-    "scripts": {
-        "clean": "rimraf dist",
-        "prebuild": "npm run clean",
-        "build": "tstl && copyfiles -u 1 \"src/**/*.d.ts\" \"src/**/*.lua\" dist && copyfiles LICENSE package.json dist",
-        "prepublishOnly": "echo You should run 'npm run publish' instead. && exit 1",
-        "publish": "npm run build && npm publish ./dist --ignore-scripts"
-    },
     "peerDependencies": {
         "@warscript/language-extensions": "^0.0.1",
-        "@warscript/tstl-plugin": "^0.0.4",
+        "@warscript/tstl-plugin": "^0.0.6",
         "lua-types": "^2.13.1",
-        "warpack": "0.0.1-dev.880fc91"
-    },
-    "devDependencies": {
-        "@typescript-eslint/eslint-plugin": "^8.13.0",
-        "@typescript-eslint/parser": "^8.13.0",
-        "async": "^3.2.6",
-        "copyfiles": "^2.4.1",
-        "eslint": "^9.14.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.2.1",
-        "prettier": "^3.3.3",
-        "rimraf": "^6.0.1",
-        "ts-node": "^10.9.2",
-        "tsc-watch": "^6.2.0"
+        "warpack": "0.0.1-dev.eb3e92a"
     },
     "publishConfig": {
         "access": "public",

package/patch-lua.lua

@@ -1,5 +1,9 @@
+local error = _G.error
 local getmetatable = _G.getmetatable
 local ipairs = _G.ipairs
+local select = _G.select
+local tostring = _G.tostring
+local tableconcat = table.concat
 
 _G.ipairs = function(t)
     local metatable = getmetatable(t)
@@ -8,3 +12,14 @@ _G.ipairs = function(t)
     end
     return ipairs(t)
 end
+
+_G.assert = function(v, ...)
+    if not v then
+        local args = {}
+        for i = 1, select("#", ...) do
+            args[i] = tostring(select(i, ...))
+        end
+        error(tableconcat(args, " "))
+    end
+    return v, ...
+end

package/patch-lualib.lua

@@ -3,7 +3,7 @@ local lualib = _G.require("lualib_bundle")
 local next = _G.next
 local ____type = _G.type
 lualib.__TS__ArrayIsArray = function(value)
-    return ____type(value) == "table" and (value[1] ~= nil or ({next(value)}) == nil) and value.constructor == nil
+    return ____type(value) == "table" and (value[1] ~= nil or (next(value)) == nil) and value.constructor == nil
 end
 local __TS__SetDescriptor = lualib.__TS__SetDescriptor
 lualib.__TS__ObjectDefineProperty = function(target, key, desc)

package/utility/arrays.d.ts

@@ -1,10 +1,16 @@
 /** @noSelfInFile */
-import { TupleOf } from "./types";
+import { NonEmptyArray, ReadonlyNonEmptyArray, TupleOf } from "./types";
 export declare const emptyArray: <T>() => readonly T[];
+/** Checks for any element with `next` instead of computing the length. */
+export declare const isNonEmptyArray: {
+    <T>(array: T[]): array is NonEmptyArray<T>;
+    <T>(array: readonly T[]): array is ReadonlyNonEmptyArray<T>;
+};
 export declare const joinToString: <T>(array: readonly T[], separator: string, transform?: (element: T) => string) => string;
 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 +28,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,15 +39,23 @@ 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>;
 export declare const filter: <T>(array: readonly T[], predicate: (value: T) => boolean) => T[];
+export declare const filterNot: <T>(array: readonly T[], predicate: (value: T) => boolean) => T[];
 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,8 +3,11 @@ 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 next = _G.next
 local select = _G.select
 local tableConcat = table.concat
 local tableSort = table.sort
@@ -12,6 +15,10 @@ local EMPTY_ARRAY = {}
 ____exports.emptyArray = function()
     return EMPTY_ARRAY
 end
+--- Checks for any element with `next` instead of computing the length.
+____exports.isNonEmptyArray = function(array)
+    return (next(array)) ~= nil
+end
 ____exports.joinToString = function(array, separator, transform)
     if transform == nil then
         transform = tostring
@@ -47,6 +54,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 +135,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 +194,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
@@ -220,6 +243,18 @@ ____exports.filter = function(array, predicate)
     end
     return result
 end
+____exports.filterNot = function(array, predicate)
+    local result = {}
+    local j = 1
+    for i = 1, #array do
+        local value = array[i]
+        if not predicate(value) then
+            result[j] = value
+            j = j + 1
+        end
+    end
+    return result
+end
 ____exports.average = function(array)
     local sum = 0
     local count = #array
@@ -251,6 +286,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,35 @@
+/** @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 ReadonlyLinkedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly keys: ReadonlyLinkedSet<K>;
+    get(key: K): V | undefined;
+    contains(key: AnyNotNil): key is K & OneSidedTypeGuard;
+    readonly size: number;
+}
+export interface LinkedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly __linkedMap: unique symbol;
+}
+export declare class LinkedMap<K extends AnyNotNil, V> implements ReadonlyLinkedMap<K, 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 __len(): number;
+    protected __pairs(this: LinkedMap<K, V>): LuaIterator<LuaMultiReturn<[K | undefined, V | undefined]>, IteratorState<K, V>>;
+}
+export declare const emptyLinkedMap: <K extends AnyNotNil, V>() => ReadonlyLinkedMap<K, V>;
+export declare const mutableLinkedMap: <K extends AnyNotNil, V>() => LinkedMap<K, V>;
+export {};

package/utility/linked-map.lua

@@ -0,0 +1,107 @@
+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 ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local ____exception = require("exception")
+local UnsupportedOperationException = ____exception.UnsupportedOperationException
+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.__len(self)
+    return self.keys.size
+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
+)
+local emptyIteratorState = {t = {}, v = {}}
+local EmptyLinkedMap = __TS__Class()
+EmptyLinkedMap.name = "EmptyLinkedMap"
+__TS__ClassExtends(EmptyLinkedMap, ____exports.LinkedMap)
+function EmptyLinkedMap.prototype.getOrPut(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyLinkedMap.prototype.put(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyLinkedMap.prototype.remove(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyLinkedMap.prototype.__len(self)
+    return 0
+end
+function EmptyLinkedMap.prototype.__pairs(self)
+    return linkedMapNext, emptyIteratorState, nil
+end
+local EMPTY_LINKED_MAP = __TS__New(EmptyLinkedMap)
+____exports.emptyLinkedMap = function()
+    return EMPTY_LINKED_MAP
+end
+____exports.mutableLinkedMap = function()
+    return __TS__New(____exports.LinkedMap)
+end
+return ____exports

package/utility/linked-set.d.ts

@@ -14,7 +14,7 @@ export interface ReadonlyLinkedSet<T extends AnyNotNil> extends LuaPairsKeyItera
     next(key: T): T | undefined;
     previous(key: T): T | undefined;
     contains(key: AnyNotNil): key is T & OneSidedTypeGuard;
-    size: number;
+    readonly 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;
@@ -36,9 +36,11 @@ 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;
+    protected addBefore(value: T, key: T): boolean;
     remove(key: T): boolean;
     contains(key: AnyNotNil): key is T & OneSidedTypeGuard;
     clear(): void;
@@ -47,9 +49,11 @@ export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet
     toArray(): T[];
     sumOf(selector: ((value: T) => number) | KeysOfType<T, number>): number;
     sortBy<R>(selector: ((value: T) => R) | KeysOfType<T, R>): void;
+    protected __len(): number;
     protected __pairs(this: LinkedSet<T>): LuaIterator<T | undefined, IteratorState<T>>;
 }
 export declare const emptyLinkedSet: <T extends AnyNotNil>() => ReadonlyLinkedSet<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>;