@wayward/types 2.11.6-beta.dev.20220502.1 → 2.12.0-beta

package/definitions/game/utilities/collection/Arrays.d.ts

@@ -1,94 +1,95 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export declare function TupleType<T>(): {
-    create: <T2 extends T[]>(...items: T2) => T2;
-};
-export declare function Tuple<T extends any[]>(...items: T): T;
-export declare module Tuple {
-    export function is<T extends any[]>(value: unknown): value is T;
-    export type TupleFilterNot<I extends 0 | 1 | 2 | 3 | 4 | 5, NOT> = <A extends any[]>(value: A) => value is Extract<[...Slice<A>[I], Exclude<A[I], NOT>, ...SliceAfter<A>[IAddOne[I]]], A>;
-    export type TupleNullishFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, undefined | null>;
-    export function filterNullish<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleNullishFilter<I>;
-    export type TupleFalsyFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, Falsy>;
-    export function filterFalsy<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleFalsyFilter<I>;
-    export type TupleGetter<I extends 0 | 1 | 2 | 3 | 4 | 5> = <A extends any[]>(value: A) => A[I];
-    export function getter<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleGetter<I>;
-    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[], R extends A[I]>(index: I, predicate: (value: A[I], i: number) => value is R): (value: A) => value is Extract<[...Slice<A>[I], R, ...SliceAfter<A>[IAddOne[I]]], A>;
-    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[]>(index: I, predicate: (value: A[I], i: number) => any): (value: A, i: number) => any;
-    interface Slice<A extends any[]> {
-        [0]: [];
-        [1]: [A[0]];
-        [2]: [A[0], A[1]];
-        [3]: [A[0], A[1], A[2]];
-        [4]: [A[0], A[1], A[2], A[3]];
-        [5]: [A[0], A[1], A[2], A[3], A[4]];
-    }
-    interface SliceAfter<A extends any[]> {
-        [1]: A extends [any, ...infer R] ? R : never;
-        [2]: A extends [any, any, ...infer R] ? R : never;
-        [3]: A extends [any, any, any, ...infer R] ? R : never;
-        [4]: A extends [any, any, any, any, ...infer R] ? R : never;
-        [5]: A extends [any, any, any, any, any, ...infer R] ? R : never;
-        [6]: A extends [any, any, any, any, any, any, ...infer R] ? R : never;
-    }
-    interface IAddOne {
-        [0]: 1;
-        [1]: 2;
-        [2]: 3;
-        [3]: 4;
-        [4]: 5;
-        [5]: 6;
-    }
-    export type Twice<T> = [T, T];
-    export {};
-}
-declare module Arrays {
-    type Value<A extends any[]> = A extends Array<infer T> ? T : never;
-    const EMPTY: readonly undefined[];
-    function repeat<A extends any[]>(count: number, ...values: A): Array<A[number]>;
-    /**
-     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive), in steps of @param step
-     * @param min A number, inclusive
-     * @param max A number, exclusive
-     * @param step The difference between each step between min and max, defaulting to 1
-     */
-    function range(min: number, max: number, step: number): number[];
-    /**
-     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive)
-     * @param min A number, inclusive
-     * @param max A number, exclusive
-     */
-    function range(min: number, max: number): number[];
-    /**
-     * Produces an array of the numbers 0 through @param max (exclusive)
-     * @param max A number, exclusive
-     */
-    function range(max: number): number[];
-    /**
-     * Note: This does not perform any deep checking
-     */
-    function equals(array1: ArrayLike<any> | undefined, array2: ArrayLike<any> | undefined): boolean;
-    /**
-     * Given a *sorted* array, a value, and a sorting function, returns the index where the value should be inserted.
-     *
-     * Notes:
-     * - If the input array is not sorted, it won't work. There is no validation to make sure that the array you put in is sorted, either.
-     * - The algorithm works in a similar way to quicksort. It pivots on the centre of the array, and figures out which side the
-     * value will fall on, then pivots on the centre of that side, then again and again until the correct location is found. This
-     * has the effect of heavily reducing the number of required sorting function calls.
-     */
-    function getSortedIndex<T>(array: ArrayLike<T>, value: T, sorter: (a: T, b: T) => number): number;
-    function pushTo<T>(arr: T[]): (...items: T[]) => number;
-    function arrayOr<T>(value: T | T[]): T[];
-    function tupleOr<A>(value: A): A extends any[] ? A : [A];
-    function concat<T>(...arrays: T[][]): T[];
-}
-export default Arrays;
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export declare function TupleType<T>(): {
+    create: <T2 extends T[]>(...items: T2) => T2;
+};
+export declare function Tuple<T extends any[]>(...items: T): T;
+export declare module Tuple {
+    export function is<T extends any[]>(value: unknown): value is T;
+    export type TupleFilterNot<I extends 0 | 1 | 2 | 3 | 4 | 5, NOT> = <A extends any[]>(value: A) => value is Extract<[...Slice<A>[I], Exclude<A[I], NOT>, ...SliceAfter<A>[IAddOne[I]]], A>;
+    export type TupleNullishFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, undefined | null>;
+    export function filterNullish<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleNullishFilter<I>;
+    export type TupleFalsyFilter<I extends 0 | 1 | 2 | 3 | 4 | 5> = TupleFilterNot<I, Falsy>;
+    export function filterFalsy<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleFalsyFilter<I>;
+    export type TupleGetter<I extends 0 | 1 | 2 | 3 | 4 | 5> = <A extends readonly any[]>(value: A) => A[I];
+    export function getter<I extends 0 | 1 | 2 | 3 | 4 | 5>(index: I): TupleGetter<I>;
+    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[], R extends A[I]>(index: I, predicate: (value: A[I], i: number) => value is R): (value: A) => value is Extract<[...Slice<A>[I], R, ...SliceAfter<A>[IAddOne[I]]], A>;
+    export function filter<I extends 0 | 1 | 2 | 3 | 4 | 5, A extends any[]>(index: I, predicate: (value: A[I], i: number) => any): (value: A, i: number) => any;
+    interface Slice<A extends any[]> {
+        [0]: [];
+        [1]: [A[0]];
+        [2]: [A[0], A[1]];
+        [3]: [A[0], A[1], A[2]];
+        [4]: [A[0], A[1], A[2], A[3]];
+        [5]: [A[0], A[1], A[2], A[3], A[4]];
+    }
+    interface SliceAfter<A extends any[]> {
+        [1]: A extends [any, ...infer R] ? R : never;
+        [2]: A extends [any, any, ...infer R] ? R : never;
+        [3]: A extends [any, any, any, ...infer R] ? R : never;
+        [4]: A extends [any, any, any, any, ...infer R] ? R : never;
+        [5]: A extends [any, any, any, any, any, ...infer R] ? R : never;
+        [6]: A extends [any, any, any, any, any, any, ...infer R] ? R : never;
+    }
+    interface IAddOne {
+        [0]: 1;
+        [1]: 2;
+        [2]: 3;
+        [3]: 4;
+        [4]: 5;
+        [5]: 6;
+    }
+    export type Twice<T> = [T, T];
+    export {};
+}
+declare module Arrays {
+    type Value<A extends any[]> = A extends Array<infer T> ? T : never;
+    const EMPTY: readonly undefined[];
+    function repeat<A extends any[]>(count: number, ...values: A): Array<A[number]>;
+    /**
+     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive), in steps of @param step
+     * @param min A number, inclusive
+     * @param max A number, exclusive
+     * @param step The difference between each step between min and max, defaulting to 1
+     */
+    function range(min: number, max: number, step: number): number[];
+    /**
+     * Produces an array of the numbers @param min (inclusive) to @param max (exclusive)
+     * @param min A number, inclusive
+     * @param max A number, exclusive
+     */
+    function range(min: number, max: number): number[];
+    /**
+     * Produces an array of the numbers 0 through @param max (exclusive)
+     * @param max A number, exclusive
+     */
+    function range(max: number): number[];
+    function equals<T>(array1: ArrayLike<T> | undefined, array2: ArrayLike<T> | undefined, valueEquals: (a: T, b: T) => any): boolean;
+    /**
+     * Note: This does not perform any deep checking
+     */
+    function equals(array1: ArrayLike<any> | undefined, array2: ArrayLike<any> | undefined): boolean;
+    /**
+     * Given a *sorted* array, a value, and a sorting function, returns the index where the value should be inserted.
+     *
+     * Notes:
+     * - If the input array is not sorted, it won't work. There is no validation to make sure that the array you put in is sorted, either.
+     * - The algorithm works in a similar way to quicksort. It pivots on the centre of the array, and figures out which side the
+     * value will fall on, then pivots on the centre of that side, then again and again until the correct location is found. This
+     * has the effect of heavily reducing the number of required sorting function calls.
+     */
+    function getSortedIndex<T>(array: ArrayLike<T>, value: T, sorter: (a: T, b: T) => number): number;
+    function pushTo<T>(arr: T[]): (...items: T[]) => number;
+    function arrayOr<T>(value: T | T[]): T[];
+    function tupleOr<A>(value: A): A extends any[] ? A : [A];
+    function concat<T>(...arrays: T[][]): T[];
+}
+export default Arrays;

package/definitions/game/utilities/collection/Graceful.d.ts

@@ -1,21 +1,21 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-import type { LogSource } from "utilities/Log";
-export declare class Graceful<T> {
-    private ifFailReturn;
-    private errorMessage;
-    private sources;
-    constructor(...sources: Array<string | LogSource>);
-    setFailureReturn(failureReturn: T): this;
-    setErrorMessage(message: string): this;
-    setSources(...sources: Array<LogSource | string>): this;
-    execute<T1 = any>(functionToCallGracefully: (arg1: T1, ...args: any[]) => T): (...args: any[]) => any;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { LogSource } from "utilities/Log";
+export declare class Graceful<T> {
+    private ifFailReturn;
+    private errorMessage;
+    private sources;
+    constructor(...sources: Array<string | LogSource>);
+    setFailureReturn(failureReturn: T): this;
+    setErrorMessage(message: string): this;
+    setSources(...sources: Array<LogSource | string>): this;
+    execute<T1 = any>(functionToCallGracefully: (arg1: T1, ...args: any[]) => T): (...args: any[]) => any;
+}

package/definitions/game/utilities/collection/Iterables.d.ts

@@ -1,17 +1,17 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export declare function isIterable(obj: any): obj is Iterable<any>;
-export declare function shortestIterable<I extends Iterable<any>, IN extends Array<Iterable<any>>>(iterable: I, ...iterables: IN): I | IN[number];
-export declare function longestIterable<I extends Iterable<any>, IN extends Array<Iterable<any>>>(iterable: I, ...iterables: IN): I | IN[number];
-export declare function length(iterable: Iterable<any>): number;
-export declare module Guard {
-    function instanceOf<T>(cls: Class<T>): (val: unknown) => val is T;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export declare function isIterable(obj: any): obj is Iterable<any>;
+export declare function shortestIterable<I extends Iterable<any>, IN extends Array<Iterable<any>>>(iterable: I, ...iterables: IN): I | IN[number];
+export declare function longestIterable<I extends Iterable<any>, IN extends Array<Iterable<any>>>(iterable: I, ...iterables: IN): I | IN[number];
+export declare function length(iterable: Iterable<any>): number;
+export declare module Guard {
+    function instanceOf<T>(cls: Class<T>): (val: unknown) => val is T;
+}

package/definitions/game/utilities/collection/map/DefaultMap.d.ts

@@ -1,20 +1,20 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-import type { ISerializer, ISerializable } from "save/serializer/ISerializer";
-import Objects from "utilities/object/Objects";
-export default class DefaultMap<K, V> extends Map<K, V> implements ISerializable, Objects.ICloneable {
-    readonly defaultValue: V;
-    constructor(defaultValue: V, entries?: Iterable<readonly [K, V]>);
-    initialize(key: K): V;
-    serializeObject(serializer: ISerializer): void;
-    deserializeObject(serializer: ISerializer): boolean;
-    [Objects.SYMBOL_CLONE](clone: typeof Objects.deepClone): this;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { ISerializer, ISerializable } from "save/serializer/ISerializer";
+import Objects from "utilities/object/Objects";
+export default class DefaultMap<K, V> extends Map<K, V> implements ISerializable, Objects.ICloneable {
+    readonly defaultValue: V;
+    constructor(defaultValue: V, entries?: Iterable<readonly [K, V]>);
+    initialize(key: K): V;
+    serializeObject(serializer: ISerializer): undefined;
+    deserializeObject(serializer: ISerializer): boolean;
+    [Objects.SYMBOL_CLONE](clone: typeof Objects.deepClone): this;
+}

package/definitions/game/utilities/collection/map/HashMap.d.ts

@@ -1,49 +1,49 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export default class HashMap<K, V> extends Map<K, V> {
-    private readonly hash;
-    private readonly hashes;
-    constructor(hash: (key: K) => string);
-    has(key: K): boolean;
-    get(key: K): V | undefined;
-    /**
-     * If the given key is present in this map, returns the value associated with it. If the given key is not present,
-     * the `defaultGenerator` parameter is called and returned.
-     * @param key The key.
-     * @param defaultGenerator A function which will return the value for this key if it is not present.
-     */
-    getOrDefault<K2 extends K, V2>(key: K2, defaultGenerator: (key: K2) => V2): V2 extends never[] ? V extends any[] ? V : (V extends V2 ? V : V | V2) : (V extends V2 ? V : V | V2);
-    /**
-     * If the given key is present in this map, returns the value associated with it. If the given key is not present,
-     * the `defaultGenerator` parameter is called and returned.
-     * @param key The key.
-     * @param defaultGenerator A function which will return the value for this key if it is not present.
-     * @param assign Whether the generated default will be stored in the map.
-     */
-    getOrDefault<K2 extends K>(key: K2, defaultGenerator: (key: K2) => V, assign: true): V;
-    set(key: K, value: V): this;
-    delete(key: K): boolean;
-    clear(): void;
-    /**
-     * Retains the entries from this map that match the given predicate function, any other entries will be deleted.
-     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
-     * @returns whether any entries remain.
-     */
-    retainWhere(predicate: (val: V, key: K) => any): boolean;
-    /**
-     * If this map contains the given key, checks whether the entry matches the given predicate.
-     * If it does, it is kept. If not, it's deleted.
-     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
-     * @returns whether any entries remain in this map.
-     */
-    retainWhere(key: K, predicate: (val: V, key: K) => any): boolean;
-    private deleteInternal;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export default class HashMap<K, V> extends Map<K, V> {
+    private readonly hash;
+    private readonly hashes;
+    constructor(hash: (key: K) => string);
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    /**
+     * If the given key is present in this map, returns the value associated with it. If the given key is not present,
+     * the `defaultGenerator` parameter is called and returned.
+     * @param key The key.
+     * @param defaultGenerator A function which will return the value for this key if it is not present.
+     */
+    getOrDefault<K2 extends K, V2>(key: K2, defaultGenerator: (key: K2) => V2): V2 extends never[] ? V extends any[] ? V : (V extends V2 ? V : V | V2) : (V extends V2 ? V : V | V2);
+    /**
+     * If the given key is present in this map, returns the value associated with it. If the given key is not present,
+     * the `defaultGenerator` parameter is called and returned.
+     * @param key The key.
+     * @param defaultGenerator A function which will return the value for this key if it is not present.
+     * @param assign Whether the generated default will be stored in the map.
+     */
+    getOrDefault<K2 extends K>(key: K2, defaultGenerator: (key: K2) => V, assign: true): V;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+    /**
+     * Retains the entries from this map that match the given predicate function, any other entries will be deleted.
+     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
+     * @returns whether any entries remain.
+     */
+    retainWhere(predicate: (val: V, key: K) => any): boolean;
+    /**
+     * If this map contains the given key, checks whether the entry matches the given predicate.
+     * If it does, it is kept. If not, it's deleted.
+     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
+     * @returns whether any entries remain in this map.
+     */
+    retainWhere(key: K, predicate: (val: V, key: K) => any): boolean;
+    private deleteInternal;
+}

package/definitions/game/utilities/collection/map/PriorityMap.d.ts

@@ -1,45 +1,45 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-/**
- * Used for ordering a list of items by "priority". Higher priorities come before lower priorities.
- */
-export declare class PriorityMap<T> {
-    static streamAll<T extends Iterable<any>>(...lists: Array<PriorityMap<T>>): import("@wayward/goodstream").default<T>;
-    private readonly priorities;
-    private readonly map;
-    get size(): number;
-    getOrDefault(priority: number): T | undefined;
-    getOrDefault(priority: number, orDefault: (priority: number) => T, assign?: boolean): T;
-    getOrDefault(priority: number, orDefault?: (priority: number) => T, assign?: boolean): T | undefined;
-    delete(priority: number): boolean;
-    /**
-     * Retains the entries from this set that match the given predicate function, any other entries will be deleted.
-     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
-     * @returns whether any entries remain.
-     */
-    retainWhere(predicate: (val: T, key: number) => any): boolean;
-    /**
-     * If this map contains the given key, checks whether the entry matches the given predicate.
-     * If it does, it is kept. If not, it's deleted.
-     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
-     * @returns whether any entries remain in this map.
-     */
-    retainWhere(key: number, predicate: (val: T, key: number) => any): boolean;
-    /**
-     * Returns an iterator of the items in this list.
-     */
-    stream(direction?: PriorityListStreamDirection): import("@wayward/goodstream").default<T>;
-    getInternalMap(): Record<number, T>;
-}
-export declare enum PriorityListStreamDirection {
-    HighestToLowest = -1,
-    LowestToHighest = 1
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+/**
+ * Used for ordering a list of items by "priority". Higher priorities come before lower priorities.
+ */
+export declare class PriorityMap<T> {
+    static streamAll<T extends Iterable<any>>(...lists: Array<PriorityMap<T>>): import("@wayward/goodstream").default<T>;
+    private readonly priorities;
+    private readonly map;
+    get size(): number;
+    getOrDefault(priority: number): T | undefined;
+    getOrDefault(priority: number, orDefault: (priority: number) => T, assign?: boolean): T;
+    getOrDefault(priority: number, orDefault?: (priority: number) => T, assign?: boolean): T | undefined;
+    delete(priority: number): boolean;
+    /**
+     * Retains the entries from this set that match the given predicate function, any other entries will be deleted.
+     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
+     * @returns whether any entries remain.
+     */
+    retainWhere(predicate: (val: T, key: number) => any): boolean;
+    /**
+     * If this map contains the given key, checks whether the entry matches the given predicate.
+     * If it does, it is kept. If not, it's deleted.
+     * @param predicate A predicate that takes a key and a value, and returns a value which will be checked for truthiness.
+     * @returns whether any entries remain in this map.
+     */
+    retainWhere(key: number, predicate: (val: T, key: number) => any): boolean;
+    /**
+     * Returns an iterator of the items in this list.
+     */
+    stream(direction?: PriorityListStreamDirection): import("@wayward/goodstream").default<T>;
+    getInternalMap(): Record<number, T>;
+}
+export declare enum PriorityListStreamDirection {
+    HighestToLowest = -1,
+    LowestToHighest = 1
+}

package/definitions/game/utilities/collection/map/StackMap.d.ts

@@ -1,15 +1,15 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export default class StackMap<K, V> extends Map<K, V> {
-    private readonly maxSize;
-    constructor(entries?: ReadonlyArray<readonly [K, V]> | null, maxSize?: number);
-    set(key: K, value: V): this;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export default class StackMap<K, V> extends Map<K, V> {
+    private readonly maxSize;
+    constructor(entries?: ReadonlyArray<readonly [K, V]> | null, maxSize?: number);
+    set(key: K, value: V): this;
+}

package/definitions/game/utilities/collection/queue/PriorityQueue.d.ts

@@ -1,25 +1,25 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export declare enum PriorityQueueType {
-    LowestToHighest = 0,
-    HighestToLowest = 1
-}
-export default class PriorityQueue<T> {
-    readonly type: PriorityQueueType;
-    private head;
-    private length;
-    constructor(type: PriorityQueueType);
-    getLength(): number;
-    isEmpty(): boolean;
-    push(data: T, priority: number): void;
-    pop(): T | undefined;
-    entries(): IterableIterator<T>;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export declare enum PriorityQueueType {
+    LowestToHighest = 0,
+    HighestToLowest = 1
+}
+export default class PriorityQueue<T> {
+    readonly type: PriorityQueueType;
+    private head;
+    private length;
+    constructor(type: PriorityQueueType);
+    getLength(): number;
+    isEmpty(): boolean;
+    push(data: T, priority: number): void;
+    pop(): T | undefined;
+    entries(): IterableIterator<T>;
+}

package/definitions/game/utilities/collection/queue/Queue.d.ts

@@ -1,20 +1,20 @@
-/*!
- * Copyright 2011-2021 Unlok
- * https://www.unlok.ca
- *
- * Credits & Thanks:
- * https://www.unlok.ca/credits-thanks/
- *
- * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
- * https://github.com/WaywardGame/types/wiki
- */
-export default class Queue<T> {
-    private queue;
-    private offset;
-    constructor(initial?: T[]);
-    getLength(): number;
-    isEmpty(): boolean;
-    enqueue(value: T): void;
-    dequeue(): T | undefined;
-    isInQueue(item: T, equals?: (item1: T, item2: T) => boolean): boolean;
-}
+/*!
+ * Copyright 2011-2021 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+export default class Queue<T> {
+    private queue;
+    private offset;
+    constructor(initial?: T[]);
+    getLength(): number;
+    isEmpty(): boolean;
+    enqueue(value: T): void;
+    dequeue(): T | undefined;
+    isInQueue(item: T, equals?: (item1: T, item2: T) => boolean): boolean;
+}