warscript 0.0.1-dev.48e5280 → 0.0.1-dev.4b6e45a

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.48e5280",
+    "version": "0.0.1-dev.4b6e45a",
     "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.e490aaf"
-    },
-    "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/utility/arrays.d.ts

@@ -1,6 +1,11 @@
 /** @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>;
@@ -42,6 +47,7 @@ export declare const associateByIndexed: <K extends AnyNotNil, V>(array: readonl
 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;

package/utility/arrays.lua

@@ -7,6 +7,7 @@ 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
@@ -14,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
@@ -238,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

package/utility/linked-map.d.ts

@@ -15,7 +15,7 @@ export interface ReadonlyLinkedMap<K extends AnyNotNil, V> extends LuaPairsItera
     readonly size: number;
 }
 export interface LinkedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
-    readonly __linkedSet: unique symbol;
+    readonly __linkedMap: unique symbol;
 }
 export declare class LinkedMap<K extends AnyNotNil, V> implements ReadonlyLinkedMap<K, V> {
     private k;
@@ -27,6 +27,7 @@ export declare class LinkedMap<K extends AnyNotNil, V> implements ReadonlyLinked
     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>;

package/utility/linked-map.lua

@@ -47,6 +47,9 @@ 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
@@ -88,6 +91,9 @@ function EmptyLinkedMap.prototype.remove(self)
         0
     )
 end
+function EmptyLinkedMap.prototype.__len(self)
+    return 0
+end
 function EmptyLinkedMap.prototype.__pairs(self)
     return linkedMapNext, emptyIteratorState, nil
 end

package/utility/linked-set.d.ts

@@ -49,6 +49,7 @@ 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>;

package/utility/linked-set.lua

@@ -188,6 +188,9 @@ function LinkedSet.prototype.sortBy(self, selector)
     self.f = array[1]
     self.l = array[s]
 end
+function LinkedSet.prototype.__len(self)
+    return self.s
+end
 function LinkedSet.prototype.__pairs(self)
     return linkedSetNext, {t = self.n, n = self.f}, nil
 end
@@ -209,6 +212,9 @@ function EmptyLinkedSet.prototype.add(self)
         0
     )
 end
+function EmptyLinkedSet.prototype.__len(self)
+    return 0
+end
 function EmptyLinkedSet.prototype.__pairs(self)
     return linkedSetNext, emptyIteratorState, nil
 end

package/utility/random.d.ts

@@ -0,0 +1,102 @@
+/** @noSelfInFile */
+import { ReadonlyNonEmptyArray } from "./types";
+/**
+ * A client-local pseudorandom generator that is safe to advance inside a local block.
+ *
+ * Instances are independent of each other and of the game's synchronous randomness.
+ */
+export declare class AsyncRandom {
+    private a;
+    private b;
+    private c;
+    private d;
+    /**
+     * Creates a generator seeded with the given `seed`,
+     * or with client-local entropy if no seed is given.
+     */
+    constructor(seed?: number);
+    /** Resets the generator to the state defined by the given `seed`. */
+    setSeed(seed: number): void;
+    /**
+     * Folds freshly gathered client-local entropy, optionally together with the given `value`,
+     * into the current state.
+     *
+     * Useful to make streams of different clients diverge even further, e.g. by mixing in values
+     * that are local by definition, such as the local player's id or the local mouse position.
+     */
+    addEntropy(value?: number | string): void;
+    /** Advances the state and returns the next 32-bit word. */
+    private next;
+    /** Returns a uniformly distributed value in `[0, bound)`, where `bound` is in `[1, 2^32]`. */
+    private nextBounded;
+    /** Returns the given amount (`0` to `32`) of random bits as a non-negative integer. */
+    nextBits(bitCount: number): number;
+    /**
+     * Returns a uniformly distributed integer, both bounds being inclusive:
+     * in `[0, upperBound]` when called with a single bound, in `[lowerBound, upperBound]` otherwise.
+     */
+    nextInteger(upperBound?: number): number;
+    nextInteger(lowerBound: number, upperBound: number): number;
+    /**
+     * Returns a uniformly distributed float with 53 bits of precision, the upper bound being
+     * exclusive: in `[0, upperBound)` when called with a single bound,
+     * in `[lowerBound, upperBound)` otherwise.
+     */
+    nextFloat(upperBound?: number): number;
+    nextFloat(lowerBound: number, upperBound: number): number;
+    /** Returns `true` with the given `probability`, or with a probability of one half by default. */
+    nextBoolean(probability?: number): boolean;
+    /** Returns a uniformly distributed angle in degrees, in `[0, 360)`. */
+    nextAngle(): number;
+    /** Returns a uniformly distributed point within `range` of the given center. */
+    nextXY(centerX: number, centerY: number, range: number): LuaMultiReturn<[x: number, y: number]>;
+    /** Returns a uniformly distributed element of the given `array`. */
+    nextElement<T>(array: ReadonlyNonEmptyArray<T>): T;
+    nextElement<T>(array: ReadonlyArray<T>): T | undefined;
+    /** Returns a uniformly distributed one of the given `elements`. */
+    nextOf<T>(element: T, ...elements: T[]): T;
+    nextOf<T>(...elements: T[]): T | undefined;
+    /** Shuffles the given `array` in place, each permutation being equally likely. */
+    shuffle(array: unknown[]): void;
+}
+/**
+ * Folds freshly gathered client-local entropy, optionally together with the given `value`,
+ * into the state of the generator backing the `asyncRandom*` functions.
+ */
+export declare const addAsyncRandomEntropy: (value?: number | string) => void;
+/** Returns the given amount (`0` to `32`) of random bits as a non-negative integer. */
+export declare const asyncRandomBits: (bitCount: number) => number;
+/**
+ * Returns a uniformly distributed integer, both bounds being inclusive:
+ * in `[0, upperBound]` when called with a single bound, in `[lowerBound, upperBound]` otherwise.
+ */
+export declare const asyncRandomInteger: {
+    (upperBound?: number): number;
+    (lowerBound: number, upperBound: number): number;
+};
+/**
+ * Returns a uniformly distributed float with 53 bits of precision, the upper bound being exclusive:
+ * in `[0, upperBound)` when called with a single bound, in `[lowerBound, upperBound)` otherwise.
+ */
+export declare const asyncRandomFloat: {
+    (upperBound?: number): number;
+    (lowerBound: number, upperBound: number): number;
+};
+/** Returns `true` with the given `probability`, or with a probability of one half by default. */
+export declare const asyncRandomBoolean: (probability?: number) => boolean;
+/** Returns a uniformly distributed angle in degrees, in `[0, 360)`. */
+export declare const asyncRandomAngle: () => number;
+/** Returns a uniformly distributed point within `range` of the given center. */
+export declare const asyncRandomXY: (centerX: number, centerY: number, range: number) => LuaMultiReturn<[x: number, y: number]>;
+/** Returns a uniformly distributed element of the given `array`. */
+export declare const asyncRandomElement: {
+    <T>(array: ReadonlyNonEmptyArray<T>): T;
+    <T>(array: ReadonlyArray<T>): T | undefined;
+};
+/** Returns a uniformly distributed one of the given `elements`. */
+export declare const asyncRandom: {
+    <T>(element: T, ...elements: T[]): T;
+    <T>(...elements: T[]): T | undefined;
+};
+/** Shuffles the given `array` in place, each permutation being equally likely. */
+export declare const asyncShuffle: (array: unknown[]) => void;

package/utility/random.lua

@@ -0,0 +1,273 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____exception = require("exception")
+local IllegalArgumentException = ____exception.IllegalArgumentException
+local ____math = require("math")
+local MAXIMUM_INTEGER = ____math.MAXIMUM_INTEGER
+local PI = ____math.PI
+local cos = ____math.cos
+local sin = ____math.sin
+local sqrt = ____math.sqrt
+local clock = os.clock
+local time = os.time
+local byte = string.byte
+local pack = string.pack
+local ____unpack = string.unpack
+local select = _G.select
+local toString = _G.tostring
+local globals = _G
+local UINT32_MASK = 4294967295
+local POW_2_32 = 4294967296
+--- 2^26, used to join two draws into a 53-bit mantissa.
+local POW_2_26 = 67108864
+--- 2^53, the amount of representable values of a 53-bit mantissa.
+local POW_2_53 = 9007199254740992
+local GOLDEN_RATIO_32 = 2654435769
+local FNV_PRIME_32 = 16777619
+--- The SplitMix32 finalizer: avalanches a 32-bit value.
+local function mix(value)
+    local z = value & UINT32_MASK
+    z = (z ~ z >> 16) * 569420461 & UINT32_MASK
+    z = (z ~ z >> 15) * 1935289751 & UINT32_MASK
+    return (z ~ z >> 15) & UINT32_MASK
+end
+--- Folds the bytes of `value` into `hash` (FNV-1a).
+local function hashString(hash, value)
+    for i = 1, #value do
+        hash = (hash ~ byte(value, i)) * FNV_PRIME_32 & UINT32_MASK
+    end
+    return hash
+end
+--- Folds the exact bit pattern of `value` into `hash`, without assuming it is an integer.
+local function hashNumber(hash, value)
+    local low, high = ____unpack(
+        "<i4i4",
+        pack("<d", value)
+    )
+    return mix(mix(hash ~ low & UINT32_MASK) ~ high & UINT32_MASK)
+end
+local entropyCounter = 0
+--- Gathers 32 bits of client-local entropy.
+-- 
+-- Every source is local by nature: the wall clock and the process CPU time drift apart between
+-- machines, and the heap addresses of freshly allocated tables and of loaded code differ between
+-- processes. The CPU time is read once more at the end, so that the time the gathering itself took
+-- contributes as well.
+local function collectEntropy()
+    entropyCounter = entropyCounter + 1
+    local entropy = mix(GOLDEN_RATIO_32 ~ entropyCounter)
+    entropy = mix(entropy ~ time() & UINT32_MASK)
+    entropy = hashNumber(
+        entropy,
+        clock()
+    )
+    entropy = mix(hashString(
+        entropy,
+        toString({})
+    ))
+    entropy = mix(hashString(
+        entropy,
+        toString({})
+    ))
+    entropy = mix(hashString(
+        entropy,
+        toString(globals)
+    ))
+    entropy = mix(hashString(
+        entropy,
+        toString(mix)
+    ))
+    return hashNumber(
+        entropy,
+        clock()
+    )
+end
+--- A client-local pseudorandom generator that is safe to advance inside a local block.
+-- 
+-- Instances are independent of each other and of the game's synchronous randomness.
+____exports.AsyncRandom = __TS__Class()
+local AsyncRandom = ____exports.AsyncRandom
+AsyncRandom.name = "AsyncRandom"
+function AsyncRandom.prototype.____constructor(self, seed)
+    self.a = 0
+    self.b = 0
+    self.c = 0
+    self.d = 0
+    self:setSeed(seed or collectEntropy())
+end
+function AsyncRandom.prototype.setSeed(self, seed)
+    local z = hashNumber(GOLDEN_RATIO_32, seed)
+    z = z + GOLDEN_RATIO_32 & UINT32_MASK
+    local a = mix(z)
+    z = z + GOLDEN_RATIO_32 & UINT32_MASK
+    local b = mix(z)
+    z = z + GOLDEN_RATIO_32 & UINT32_MASK
+    local c = mix(z)
+    z = z + GOLDEN_RATIO_32 & UINT32_MASK
+    local d = mix(z)
+    self.a = a
+    self.b = b
+    self.c = c
+    self.d = a | b | c | d ~= 0 and d or GOLDEN_RATIO_32
+end
+function AsyncRandom.prototype.addEntropy(self, value)
+    local entropy = collectEntropy()
+    if type(value) == "number" then
+        entropy = hashNumber(entropy, value)
+    elseif value ~= nil then
+        entropy = hashString(entropy, value)
+    end
+    local a = self.a ~ mix(entropy)
+    local b = self.b ~ mix(a)
+    local c = self.c ~ mix(b)
+    local d = self.d ~ mix(c)
+    self.a = a
+    self.b = b
+    self.c = c
+    self.d = a | b | c | d ~= 0 and d or GOLDEN_RATIO_32
+    self:next()
+end
+function AsyncRandom.prototype.next(self)
+    local a = self.a
+    local b = self.b
+    local result = b * 5 & UINT32_MASK
+    result = (result << 7 | result >> 25) & UINT32_MASK
+    result = result * 9 & UINT32_MASK
+    local t = b << 9 & UINT32_MASK
+    local c = self.c ~ a
+    local d = self.d ~ b
+    self.a = a ~ d
+    self.b = b ~ c
+    self.c = c ~ t
+    self.d = (d << 11 | d >> 21) & UINT32_MASK
+    return result
+end
+function AsyncRandom.prototype.nextBounded(self, bound)
+    if bound <= 1 then
+        return 0
+    end
+    local limit = POW_2_32 - POW_2_32 % bound
+    local value = self:next()
+    while value >= limit do
+        value = self:next()
+    end
+    return value % bound
+end
+function AsyncRandom.prototype.nextBits(self, bitCount)
+    return self:next() >> 32 - bitCount
+end
+function AsyncRandom.prototype.nextInteger(self, m, n)
+    local lowerBound = n ~= nil and m or 0
+    local upperBound = n ~= nil and n or (m or MAXIMUM_INTEGER)
+    if upperBound < lowerBound then
+        error(
+            __TS__New(
+                IllegalArgumentException,
+                ((("Upper bound (" .. tostring(upperBound)) .. ") is less than lower bound (") .. tostring(lowerBound)) .. ")."
+            ),
+            0
+        )
+    end
+    return lowerBound + self:nextBounded(upperBound - lowerBound + 1)
+end
+function AsyncRandom.prototype.nextFloat(self, m, n)
+    local high = self:next() >> 5
+    local low = self:next() >> 6
+    local value = (high * POW_2_26 + low) / POW_2_53
+    return n ~= nil and m + value * (n - m) or value * (m or MAXIMUM_INTEGER)
+end
+function AsyncRandom.prototype.nextBoolean(self, probability)
+    local ____temp_0
+    if probability == nil then
+        ____temp_0 = self:next() >> 31 ~= 0
+    else
+        ____temp_0 = self:nextFloat() < probability
+    end
+    return ____temp_0
+end
+function AsyncRandom.prototype.nextAngle(self)
+    return self:nextFloat() * 360
+end
+function AsyncRandom.prototype.nextXY(self, centerX, centerY, range)
+    local r = range * sqrt(self:nextFloat())
+    local t = self:nextFloat() * 2 * PI
+    return centerX + r * cos(t), centerY + r * sin(t)
+end
+function AsyncRandom.prototype.nextElement(self, array)
+    local length = #array
+    local ____temp_1
+    if length ~= 0 then
+        ____temp_1 = array[self:nextBounded(length) + 1]
+    else
+        ____temp_1 = nil
+    end
+    return ____temp_1
+end
+function AsyncRandom.prototype.nextOf(self, ...)
+    local count = select("#", ...)
+    local ____temp_2
+    if count ~= 0 then
+        ____temp_2 = (select(
+            self:nextBounded(count) + 1,
+            ...
+        ))
+    else
+        ____temp_2 = nil
+    end
+    return ____temp_2
+end
+function AsyncRandom.prototype.shuffle(self, array)
+    for i = #array - 1, 1, -1 do
+        local j = self:nextBounded(i + 1)
+        local value = array[i + 1]
+        array[i + 1] = array[j + 1]
+        array[j + 1] = value
+    end
+end
+local defaultAsyncRandom
+local function getDefaultAsyncRandom()
+    defaultAsyncRandom = defaultAsyncRandom or __TS__New(____exports.AsyncRandom)
+    return defaultAsyncRandom
+end
+--- Folds freshly gathered client-local entropy, optionally together with the given `value`,
+-- into the state of the generator backing the `asyncRandom*` functions.
+____exports.addAsyncRandomEntropy = function(value)
+    getDefaultAsyncRandom():addEntropy(value)
+end
+--- Returns the given amount (`0` to `32`) of random bits as a non-negative integer.
+____exports.asyncRandomBits = function(bitCount)
+    return getDefaultAsyncRandom():nextBits(bitCount)
+end
+--- Returns a uniformly distributed integer, both bounds being inclusive:
+-- in `[0, upperBound]` when called with a single bound, in `[lowerBound, upperBound]` otherwise.
+____exports.asyncRandomInteger = function(m, n) return n ~= nil and getDefaultAsyncRandom():nextInteger(m, n) or getDefaultAsyncRandom():nextInteger(m) end
+--- Returns a uniformly distributed float with 53 bits of precision, the upper bound being exclusive:
+-- in `[0, upperBound)` when called with a single bound, in `[lowerBound, upperBound)` otherwise.
+____exports.asyncRandomFloat = function(m, n) return n ~= nil and getDefaultAsyncRandom():nextFloat(m, n) or getDefaultAsyncRandom():nextFloat(m) end
+--- Returns `true` with the given `probability`, or with a probability of one half by default.
+____exports.asyncRandomBoolean = function(probability)
+    return getDefaultAsyncRandom():nextBoolean(probability)
+end
+--- Returns a uniformly distributed angle in degrees, in `[0, 360)`.
+____exports.asyncRandomAngle = function()
+    return getDefaultAsyncRandom():nextAngle()
+end
+--- Returns a uniformly distributed point within `range` of the given center.
+____exports.asyncRandomXY = function(centerX, centerY, range)
+    return getDefaultAsyncRandom():nextXY(centerX, centerY, range)
+end
+--- Returns a uniformly distributed element of the given `array`.
+____exports.asyncRandomElement = function(array)
+    return getDefaultAsyncRandom():nextElement(array)
+end
+--- Returns a uniformly distributed one of the given `elements`.
+____exports.asyncRandom = function(...)
+    return getDefaultAsyncRandom():nextOf(...)
+end
+--- Shuffles the given `array` in place, each permutation being equally likely.
+____exports.asyncShuffle = function(array)
+    getDefaultAsyncRandom():shuffle(array)
+end
+return ____exports

package/utility/unordered-map.d.ts

@@ -0,0 +1,27 @@
+/** @noSelfInFile */
+type OneSidedTypeGuard = {
+    readonly __oneSidedTypeGuard: unique symbol;
+};
+export interface ReadonlyUnorderedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    get(key: K): V | undefined;
+    contains(key: AnyNotNil): key is K & OneSidedTypeGuard;
+    readonly size: number;
+}
+export interface UnorderedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly __unorderedMap: unique symbol;
+}
+export declare class UnorderedMap<K extends AnyNotNil, V> implements ReadonlyUnorderedMap<K, V> {
+    private readonly v;
+    private s;
+    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: UnorderedMap<K, V>): ReturnType<typeof pairs>;
+}
+export declare const emptyUnorderedMap: <K extends AnyNotNil, V>() => ReadonlyUnorderedMap<K, V>;
+export declare const mutableUnorderedMap: <K extends AnyNotNil, V>() => UnorderedMap<K, V>;
+export {};