@jubbio/core 1.1.20 → 1.3.2

package/dist/cjs/utils/BitField.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Generic BitField class
+ * API compatible with Discord.js BitField
+ */
+export type BitFieldResolvable<S extends string, N extends bigint | number> = N | N[] | S | S[] | BitField<S, N>;
+/**
+ * Data structure for bit fields
+ */
+export declare class BitField<S extends string = string, N extends bigint | number = bigint> {
+    /** The raw bits */
+    bitfield: N;
+    /** Flags for this bitfield (override in subclass) */
+    static Flags: Record<string, bigint | number>;
+    /** Default bit value */
+    static DefaultBit: bigint | number;
+    constructor(bits?: BitFieldResolvable<S, N>);
+    /**
+     * Check if this bitfield has a bit
+     */
+    has(bit: BitFieldResolvable<S, N>): boolean;
+    /**
+     * Check if this bitfield has any of the bits
+     */
+    any(bits: BitFieldResolvable<S, N>): boolean;
+    /**
+     * Add bits to this bitfield
+     */
+    add(...bits: BitFieldResolvable<S, N>[]): this;
+    /**
+     * Remove bits from this bitfield
+     */
+    remove(...bits: BitFieldResolvable<S, N>[]): this;
+    /**
+     * Serialize to array of flag names
+     */
+    toArray(): S[];
+    /**
+     * Serialize to JSON
+     */
+    toJSON(): string | number;
+    /**
+     * Get string representation
+     */
+    toString(): string;
+    /**
+     * Get iterator
+     */
+    [Symbol.iterator](): IterableIterator<S>;
+    /**
+     * Freeze this bitfield
+     */
+    freeze(): Readonly<this>;
+    /**
+     * Check equality
+     */
+    equals(other: BitFieldResolvable<S, N>): boolean;
+    /**
+     * Clone this bitfield
+     */
+    clone(): BitField<S, N>;
+    /**
+     * Resolve a bit to the numeric type
+     */
+    static resolve<S extends string, N extends bigint | number>(bit: BitFieldResolvable<S, N>): N;
+}
+export default BitField;

package/dist/cjs/utils/BitField.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Generic BitField class
+ * API compatible with Discord.js BitField
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitField = void 0;
+/**
+ * Data structure for bit fields
+ */
+class BitField {
+    /** The raw bits */
+    bitfield;
+    /** Flags for this bitfield (override in subclass) */
+    static Flags = {};
+    /** Default bit value */
+    static DefaultBit = 0n;
+    constructor(bits = BitField.DefaultBit) {
+        this.bitfield = this.constructor.resolve(bits);
+    }
+    /**
+     * Check if this bitfield has a bit
+     */
+    has(bit) {
+        const resolved = this.constructor.resolve(bit);
+        return (this.bitfield & resolved) === resolved;
+    }
+    /**
+     * Check if this bitfield has any of the bits
+     */
+    any(bits) {
+        const resolved = this.constructor.resolve(bits);
+        return (this.bitfield & resolved) !== 0n;
+    }
+    /**
+     * Add bits to this bitfield
+     */
+    add(...bits) {
+        let total = 0n;
+        for (const bit of bits) {
+            total |= this.constructor.resolve(bit);
+        }
+        this.bitfield |= total;
+        return this;
+    }
+    /**
+     * Remove bits from this bitfield
+     */
+    remove(...bits) {
+        let total = 0n;
+        for (const bit of bits) {
+            total |= this.constructor.resolve(bit);
+        }
+        this.bitfield &= ~total;
+        return this;
+    }
+    /**
+     * Serialize to array of flag names
+     */
+    toArray() {
+        const flags = this.constructor.Flags;
+        const result = [];
+        for (const [name, bit] of Object.entries(flags)) {
+            if (this.bitfield & bit) {
+                result.push(name);
+            }
+        }
+        return result;
+    }
+    /**
+     * Serialize to JSON
+     */
+    toJSON() {
+        return typeof this.bitfield === 'bigint'
+            ? this.bitfield.toString()
+            : this.bitfield;
+    }
+    /**
+     * Get string representation
+     */
+    toString() {
+        return this.bitfield.toString();
+    }
+    /**
+     * Get iterator
+     */
+    *[Symbol.iterator]() {
+        yield* this.toArray();
+    }
+    /**
+     * Freeze this bitfield
+     */
+    freeze() {
+        return Object.freeze(this);
+    }
+    /**
+     * Check equality
+     */
+    equals(other) {
+        return this.bitfield === this.constructor.resolve(other);
+    }
+    /**
+     * Clone this bitfield
+     */
+    clone() {
+        return new this.constructor(this.bitfield);
+    }
+    /**
+     * Resolve a bit to the numeric type
+     */
+    static resolve(bit) {
+        if (typeof bit === 'bigint' || typeof bit === 'number') {
+            return bit;
+        }
+        if (bit instanceof BitField) {
+            return bit.bitfield;
+        }
+        if (typeof bit === 'string') {
+            const resolved = this.Flags[bit];
+            if (resolved === undefined) {
+                throw new Error(`Unknown bit: ${bit}`);
+            }
+            return resolved;
+        }
+        if (Array.isArray(bit)) {
+            let result = this.DefaultBit;
+            for (const b of bit) {
+                const resolved = this.resolve(b);
+                result |= resolved;
+            }
+            return result;
+        }
+        throw new Error(`Invalid bit: ${bit}`);
+    }
+}
+exports.BitField = BitField;
+exports.default = BitField;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BitField.js","sourceRoot":"","sources":["../../../src/utils/BitField.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AASH;;GAEG;AACH,MAAa,QAAQ;IACnB,mBAAmB;IACZ,QAAQ,CAAI;IAEnB,qDAAqD;IACrD,MAAM,CAAC,KAAK,GAAoC,EAAE,CAAC;IAEnD,wBAAwB;IACxB,MAAM,CAAC,UAAU,GAAoB,EAAE,CAAC;IAExC,YAAY,OAAiC,QAAQ,CAAC,UAAe;QACnE,IAAI,CAAC,QAAQ,GAAI,IAAI,CAAC,WAA+B,CAAC,OAAO,CAAO,IAAI,CAAC,CAAC;IAC5E,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,GAA6B;QAC/B,MAAM,QAAQ,GAAI,IAAI,CAAC,WAA+B,CAAC,OAAO,CAAO,GAAG,CAAC,CAAC;QAC1E,OAAO,CAAE,IAAI,CAAC,QAAmB,GAAI,QAAmB,CAAC,KAAM,QAAmB,CAAC;IACrF,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,IAA8B;QAChC,MAAM,QAAQ,GAAI,IAAI,CAAC,WAA+B,CAAC,OAAO,CAAO,IAAI,CAAC,CAAC;QAC3E,OAAO,CAAE,IAAI,CAAC,QAAmB,GAAI,QAAmB,CAAC,KAAK,EAAE,CAAC;IACnE,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,GAAG,IAAgC;QACrC,IAAI,KAAK,GAAG,EAAE,CAAC;QACf,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,KAAK,IAAK,IAAI,CAAC,WAA+B,CAAC,OAAO,CAAO,GAAG,CAAW,CAAC;QAC9E,CAAC;QACA,IAAI,CAAC,QAAmB,IAAI,KAAK,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,GAAG,IAAgC;QACxC,IAAI,KAAK,GAAG,EAAE,CAAC;QACf,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,KAAK,IAAK,IAAI,CAAC,WAA+B,CAAC,OAAO,CAAO,GAAG,CAAW,CAAC;QAC9E,CAAC;QACA,IAAI,CAAC,QAAmB,IAAI,CAAC,KAAK,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,OAAO;QACL,MAAM,KAAK,GAAI,IAAI,CAAC,WAA+B,CAAC,KAAK,CAAC;QAC1D,MAAM,MAAM,GAAQ,EAAE,CAAC;QAEvB,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAChD,IAAK,IAAI,CAAC,QAAmB,GAAI,GAAc,EAAE,CAAC;gBAChD,MAAM,CAAC,IAAI,CAAC,IAAS,CAAC,CAAC;YACzB,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,OAAO,IAAI,CAAC,QAAQ,KAAK,QAAQ;YACtC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE;YAC1B,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;QAChB,KAAK,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAA+B;QACpC,OAAO,IAAI,CAAC,QAAQ,KAAM,IAAI,CAAC,WAA+B,CAAC,OAAO,CAAO,KAAK,CAAC,CAAC;IACtF,CAAC;IAED;;OAEG;IACH,KAAK;QACH,OAAO,IAAK,IAAI,CAAC,WAA+C,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClF,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,OAAO,CAA8C,GAA6B;QACvF,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACvD,OAAO,GAAQ,CAAC;QAClB,CAAC;QAED,IAAI,GAAG,YAAY,QAAQ,EAAE,CAAC;YAC5B,OAAO,GAAG,CAAC,QAAa,CAAC;QAC3B,CAAC;QAED,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACjC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBAC3B,MAAM,IAAI,KAAK,CAAC,gBAAgB,GAAG,EAAE,CAAC,CAAC;YACzC,CAAC;YACD,OAAO,QAAa,CAAC;QACvB,CAAC;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACvB,IAAI,MAAM,GAAG,IAAI,CAAC,UAAoB,CAAC;YACvC,KAAK,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC;gBACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAO,CAAC,CAAC,CAAC;gBACvC,MAAM,IAAI,QAAkB,CAAC;YAC/B,CAAC;YACD,OAAO,MAAW,CAAC;QACrB,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,gBAAgB,GAAG,EAAE,CAAC,CAAC;IACzC,CAAC;;AAhJH,4BAiJC;AAED,kBAAe,QAAQ,CAAC","sourcesContent":["/**\n * Generic BitField class\n * API compatible with Discord.js BitField\n */\n\nexport type BitFieldResolvable<S extends string, N extends bigint | number> = \n  | N \n  | N[] \n  | S \n  | S[] \n  | BitField<S, N>;\n\n/**\n * Data structure for bit fields\n */\nexport class BitField<S extends string = string, N extends bigint | number = bigint> {\n  /** The raw bits */\n  public bitfield: N;\n\n  /** Flags for this bitfield (override in subclass) */\n  static Flags: Record<string, bigint | number> = {};\n\n  /** Default bit value */\n  static DefaultBit: bigint | number = 0n;\n\n  constructor(bits: BitFieldResolvable<S, N> = BitField.DefaultBit as N) {\n    this.bitfield = (this.constructor as typeof BitField).resolve<S, N>(bits);\n  }\n\n  /**\n   * Check if this bitfield has a bit\n   */\n  has(bit: BitFieldResolvable<S, N>): boolean {\n    const resolved = (this.constructor as typeof BitField).resolve<S, N>(bit);\n    return ((this.bitfield as bigint) & (resolved as bigint)) === (resolved as bigint);\n  }\n\n  /**\n   * Check if this bitfield has any of the bits\n   */\n  any(bits: BitFieldResolvable<S, N>): boolean {\n    const resolved = (this.constructor as typeof BitField).resolve<S, N>(bits);\n    return ((this.bitfield as bigint) & (resolved as bigint)) !== 0n;\n  }\n\n  /**\n   * Add bits to this bitfield\n   */\n  add(...bits: BitFieldResolvable<S, N>[]): this {\n    let total = 0n;\n    for (const bit of bits) {\n      total |= (this.constructor as typeof BitField).resolve<S, N>(bit) as bigint;\n    }\n    (this.bitfield as bigint) |= total;\n    return this;\n  }\n\n  /**\n   * Remove bits from this bitfield\n   */\n  remove(...bits: BitFieldResolvable<S, N>[]): this {\n    let total = 0n;\n    for (const bit of bits) {\n      total |= (this.constructor as typeof BitField).resolve<S, N>(bit) as bigint;\n    }\n    (this.bitfield as bigint) &= ~total;\n    return this;\n  }\n\n  /**\n   * Serialize to array of flag names\n   */\n  toArray(): S[] {\n    const flags = (this.constructor as typeof BitField).Flags;\n    const result: S[] = [];\n    \n    for (const [name, bit] of Object.entries(flags)) {\n      if ((this.bitfield as bigint) & (bit as bigint)) {\n        result.push(name as S);\n      }\n    }\n    \n    return result;\n  }\n\n  /**\n   * Serialize to JSON\n   */\n  toJSON(): string | number {\n    return typeof this.bitfield === 'bigint' \n      ? this.bitfield.toString() \n      : this.bitfield;\n  }\n\n  /**\n   * Get string representation\n   */\n  toString(): string {\n    return this.bitfield.toString();\n  }\n\n  /**\n   * Get iterator\n   */\n  *[Symbol.iterator](): IterableIterator<S> {\n    yield* this.toArray();\n  }\n\n  /**\n   * Freeze this bitfield\n   */\n  freeze(): Readonly<this> {\n    return Object.freeze(this);\n  }\n\n  /**\n   * Check equality\n   */\n  equals(other: BitFieldResolvable<S, N>): boolean {\n    return this.bitfield === (this.constructor as typeof BitField).resolve<S, N>(other);\n  }\n\n  /**\n   * Clone this bitfield\n   */\n  clone(): BitField<S, N> {\n    return new (this.constructor as new (bits: N) => BitField<S, N>)(this.bitfield);\n  }\n\n  /**\n   * Resolve a bit to the numeric type\n   */\n  static resolve<S extends string, N extends bigint | number>(bit: BitFieldResolvable<S, N>): N {\n    if (typeof bit === 'bigint' || typeof bit === 'number') {\n      return bit as N;\n    }\n\n    if (bit instanceof BitField) {\n      return bit.bitfield as N;\n    }\n\n    if (typeof bit === 'string') {\n      const resolved = this.Flags[bit];\n      if (resolved === undefined) {\n        throw new Error(`Unknown bit: ${bit}`);\n      }\n      return resolved as N;\n    }\n\n    if (Array.isArray(bit)) {\n      let result = this.DefaultBit as bigint;\n      for (const b of bit) {\n        const resolved = this.resolve<S, N>(b);\n        result |= resolved as bigint;\n      }\n      return result as N;\n    }\n\n    throw new Error(`Invalid bit: ${bit}`);\n  }\n}\n\nexport default BitField;\n"]}

package/dist/cjs/utils/Collection.d.ts

@@ -0,0 +1,116 @@
+/**
+ * A Map with additional utility methods
+ */
+export declare class Collection<K, V> extends Map<K, V> {
+    /**
+     * Identical to Map.get()
+     * Ensures the value exists
+     */
+    ensure(key: K, defaultValueGenerator: (key: K, collection: this) => V): V;
+    /**
+     * Checks if all items pass a test
+     */
+    every(fn: (value: V, key: K, collection: this) => boolean): boolean;
+    /**
+     * Checks if any item passes a test
+     */
+    some(fn: (value: V, key: K, collection: this) => boolean): boolean;
+    /**
+     * Identical to Array.filter(), but returns a Collection
+     */
+    filter(fn: (value: V, key: K, collection: this) => boolean): Collection<K, V>;
+    /**
+     * Partitions the collection into two collections
+     */
+    partition(fn: (value: V, key: K, collection: this) => boolean): [Collection<K, V>, Collection<K, V>];
+    /**
+     * Maps each item to another value
+     */
+    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
+    /**
+     * Maps each item to another value into a Collection
+     */
+    mapValues<T>(fn: (value: V, key: K, collection: this) => T): Collection<K, T>;
+    /**
+     * Searches for a single item
+     */
+    find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;
+    /**
+     * Searches for the key of a single item
+     */
+    findKey(fn: (value: V, key: K, collection: this) => boolean): K | undefined;
+    /**
+     * Removes items that satisfy the provided filter function
+     */
+    sweep(fn: (value: V, key: K, collection: this) => boolean): number;
+    /**
+     * Reduces the collection to a single value
+     */
+    reduce<T>(fn: (accumulator: T, value: V, key: K, collection: this) => T, initialValue: T): T;
+    /**
+     * Identical to Array.forEach()
+     */
+    each(fn: (value: V, key: K, collection: this) => void): this;
+    /**
+     * Returns the first item(s) in the collection
+     */
+    first(): V | undefined;
+    first(amount: number): V[];
+    /**
+     * Returns the first key(s) in the collection
+     */
+    firstKey(): K | undefined;
+    firstKey(amount: number): K[];
+    /**
+     * Returns the last item(s) in the collection
+     */
+    last(): V | undefined;
+    last(amount: number): V[];
+    /**
+     * Returns the last key(s) in the collection
+     */
+    lastKey(): K | undefined;
+    lastKey(amount: number): K[];
+    /**
+     * Returns a random item from the collection
+     */
+    random(): V | undefined;
+    random(amount: number): V[];
+    /**
+     * Returns a random key from the collection
+     */
+    randomKey(): K | undefined;
+    randomKey(amount: number): K[];
+    /**
+     * Combines this collection with others
+     */
+    concat(...collections: Collection<K, V>[]): Collection<K, V>;
+    /**
+     * Checks if this collection shares identical items with another
+     */
+    equals(collection: Collection<K, V>): boolean;
+    /**
+     * Creates an identical shallow copy of this collection
+     */
+    clone(): Collection<K, V>;
+    /**
+     * Sorts the collection and returns it
+     */
+    sort(compareFunction?: (firstValue: V, secondValue: V, firstKey: K, secondKey: K) => number): this;
+    /**
+     * Sorts the collection by keys and returns it
+     */
+    sortByKey(compareFunction?: (firstKey: K, secondKey: K, firstValue: V, secondValue: V) => number): this;
+    /**
+     * Returns an array of items
+     */
+    toJSON(): V[];
+    /**
+     * Default sort function
+     */
+    private static defaultSort;
+    /**
+     * Creates a Collection from an array
+     */
+    static from<K, V>(entries: Iterable<readonly [K, V]>): Collection<K, V>;
+}

package/dist/cjs/utils/Collection.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+/**
+ * A Map with additional utility methods
+ */
+class Collection extends Map {
+    /**
+     * Identical to Map.get()
+     * Ensures the value exists
+     */
+    ensure(key, defaultValueGenerator) {
+        if (this.has(key))
+            return this.get(key);
+        const defaultValue = defaultValueGenerator(key, this);
+        this.set(key, defaultValue);
+        return defaultValue;
+    }
+    /**
+     * Checks if all items pass a test
+     */
+    every(fn) {
+        for (const [key, val] of this) {
+            if (!fn(val, key, this))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Checks if any item passes a test
+     */
+    some(fn) {
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Identical to Array.filter(), but returns a Collection
+     */
+    filter(fn) {
+        const results = new Collection();
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                results.set(key, val);
+        }
+        return results;
+    }
+    /**
+     * Partitions the collection into two collections
+     */
+    partition(fn) {
+        const results = [new Collection(), new Collection()];
+        for (const [key, val] of this) {
+            if (fn(val, key, this)) {
+                results[0].set(key, val);
+            }
+            else {
+                results[1].set(key, val);
+            }
+        }
+        return results;
+    }
+    /**
+     * Maps each item to another value
+     */
+    map(fn) {
+        const results = [];
+        for (const [key, val] of this) {
+            results.push(fn(val, key, this));
+        }
+        return results;
+    }
+    /**
+     * Maps each item to another value into a Collection
+     */
+    mapValues(fn) {
+        const results = new Collection();
+        for (const [key, val] of this) {
+            results.set(key, fn(val, key, this));
+        }
+        return results;
+    }
+    /**
+     * Searches for a single item
+     */
+    find(fn) {
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                return val;
+        }
+        return undefined;
+    }
+    /**
+     * Searches for the key of a single item
+     */
+    findKey(fn) {
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                return key;
+        }
+        return undefined;
+    }
+    /**
+     * Removes items that satisfy the provided filter function
+     */
+    sweep(fn) {
+        const previousSize = this.size;
+        for (const [key, val] of this) {
+            if (fn(val, key, this))
+                this.delete(key);
+        }
+        return previousSize - this.size;
+    }
+    /**
+     * Reduces the collection to a single value
+     */
+    reduce(fn, initialValue) {
+        let accumulator = initialValue;
+        for (const [key, val] of this) {
+            accumulator = fn(accumulator, val, key, this);
+        }
+        return accumulator;
+    }
+    /**
+     * Identical to Array.forEach()
+     */
+    each(fn) {
+        for (const [key, val] of this) {
+            fn(val, key, this);
+        }
+        return this;
+    }
+    first(amount) {
+        if (amount === undefined)
+            return this.values().next().value;
+        if (amount < 0)
+            return this.last(amount * -1);
+        amount = Math.min(this.size, amount);
+        const iter = this.values();
+        return Array.from({ length: amount }, () => iter.next().value);
+    }
+    firstKey(amount) {
+        if (amount === undefined)
+            return this.keys().next().value;
+        if (amount < 0)
+            return this.lastKey(amount * -1);
+        amount = Math.min(this.size, amount);
+        const iter = this.keys();
+        return Array.from({ length: amount }, () => iter.next().value);
+    }
+    last(amount) {
+        const arr = [...this.values()];
+        if (amount === undefined)
+            return arr[arr.length - 1];
+        if (amount < 0)
+            return this.first(amount * -1);
+        if (!amount)
+            return [];
+        return arr.slice(-amount);
+    }
+    lastKey(amount) {
+        const arr = [...this.keys()];
+        if (amount === undefined)
+            return arr[arr.length - 1];
+        if (amount < 0)
+            return this.firstKey(amount * -1);
+        if (!amount)
+            return [];
+        return arr.slice(-amount);
+    }
+    random(amount) {
+        const arr = [...this.values()];
+        if (amount === undefined)
+            return arr[Math.floor(Math.random() * arr.length)];
+        if (!arr.length || !amount)
+            return [];
+        return Array.from({ length: Math.min(amount, arr.length) }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);
+    }
+    randomKey(amount) {
+        const arr = [...this.keys()];
+        if (amount === undefined)
+            return arr[Math.floor(Math.random() * arr.length)];
+        if (!arr.length || !amount)
+            return [];
+        return Array.from({ length: Math.min(amount, arr.length) }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);
+    }
+    /**
+     * Combines this collection with others
+     */
+    concat(...collections) {
+        const newColl = this.clone();
+        for (const coll of collections) {
+            for (const [key, val] of coll)
+                newColl.set(key, val);
+        }
+        return newColl;
+    }
+    /**
+     * Checks if this collection shares identical items with another
+     */
+    equals(collection) {
+        if (this === collection)
+            return true;
+        if (this.size !== collection.size)
+            return false;
+        for (const [key, value] of this) {
+            if (!collection.has(key) || value !== collection.get(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Creates an identical shallow copy of this collection
+     */
+    clone() {
+        return new Collection(this);
+    }
+    /**
+     * Sorts the collection and returns it
+     */
+    sort(compareFunction = Collection.defaultSort) {
+        const entries = [...this.entries()];
+        entries.sort((a, b) => compareFunction(a[1], b[1], a[0], b[0]));
+        this.clear();
+        for (const [k, v] of entries) {
+            this.set(k, v);
+        }
+        return this;
+    }
+    /**
+     * Sorts the collection by keys and returns it
+     */
+    sortByKey(compareFunction = Collection.defaultSort) {
+        const entries = [...this.entries()];
+        entries.sort((a, b) => compareFunction(a[0], b[0], a[1], b[1]));
+        this.clear();
+        for (const [k, v] of entries) {
+            this.set(k, v);
+        }
+        return this;
+    }
+    /**
+     * Returns an array of items
+     */
+    toJSON() {
+        return [...this.values()];
+    }
+    /**
+     * Default sort function
+     */
+    static defaultSort(firstValue, secondValue) {
+        return Number(firstValue > secondValue) || Number(firstValue === secondValue) - 1;
+    }
+    /**
+     * Creates a Collection from an array
+     */
+    static from(entries) {
+        return new Collection(entries);
+    }
+}
+exports.Collection = Collection;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Collection.js","sourceRoot":"","sources":["../../../src/utils/Collection.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A Map with additional utility methods\n */\nexport class Collection<K, V> extends Map<K, V> {\n  /**\n   * Identical to Map.get()\n   * Ensures the value exists\n   */\n  ensure(key: K, defaultValueGenerator: (key: K, collection: this) => V): V {\n    if (this.has(key)) return this.get(key)!;\n    const defaultValue = defaultValueGenerator(key, this);\n    this.set(key, defaultValue);\n    return defaultValue;\n  }\n\n  /**\n   * Checks if all items pass a test\n   */\n  every(fn: (value: V, key: K, collection: this) => boolean): boolean {\n    for (const [key, val] of this) {\n      if (!fn(val, key, this)) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Checks if any item passes a test\n   */\n  some(fn: (value: V, key: K, collection: this) => boolean): boolean {\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) return true;\n    }\n    return false;\n  }\n\n  /**\n   * Identical to Array.filter(), but returns a Collection\n   */\n  filter(fn: (value: V, key: K, collection: this) => boolean): Collection<K, V> {\n    const results = new Collection<K, V>();\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) results.set(key, val);\n    }\n    return results;\n  }\n\n  /**\n   * Partitions the collection into two collections\n   */\n  partition(fn: (value: V, key: K, collection: this) => boolean): [Collection<K, V>, Collection<K, V>] {\n    const results: [Collection<K, V>, Collection<K, V>] = [new Collection<K, V>(), new Collection<K, V>()];\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) {\n        results[0].set(key, val);\n      } else {\n        results[1].set(key, val);\n      }\n    }\n    return results;\n  }\n\n  /**\n   * Maps each item to another value\n   */\n  map<T>(fn: (value: V, key: K, collection: this) => T): T[] {\n    const results: T[] = [];\n    for (const [key, val] of this) {\n      results.push(fn(val, key, this));\n    }\n    return results;\n  }\n\n  /**\n   * Maps each item to another value into a Collection\n   */\n  mapValues<T>(fn: (value: V, key: K, collection: this) => T): Collection<K, T> {\n    const results = new Collection<K, T>();\n    for (const [key, val] of this) {\n      results.set(key, fn(val, key, this));\n    }\n    return results;\n  }\n\n  /**\n   * Searches for a single item\n   */\n  find(fn: (value: V, key: K, collection: this) => boolean): V | undefined {\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) return val;\n    }\n    return undefined;\n  }\n\n  /**\n   * Searches for the key of a single item\n   */\n  findKey(fn: (value: V, key: K, collection: this) => boolean): K | undefined {\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) return key;\n    }\n    return undefined;\n  }\n\n  /**\n   * Removes items that satisfy the provided filter function\n   */\n  sweep(fn: (value: V, key: K, collection: this) => boolean): number {\n    const previousSize = this.size;\n    for (const [key, val] of this) {\n      if (fn(val, key, this)) this.delete(key);\n    }\n    return previousSize - this.size;\n  }\n\n  /**\n   * Reduces the collection to a single value\n   */\n  reduce<T>(fn: (accumulator: T, value: V, key: K, collection: this) => T, initialValue: T): T {\n    let accumulator = initialValue;\n    for (const [key, val] of this) {\n      accumulator = fn(accumulator, val, key, this);\n    }\n    return accumulator;\n  }\n\n  /**\n   * Identical to Array.forEach()\n   */\n  each(fn: (value: V, key: K, collection: this) => void): this {\n    for (const [key, val] of this) {\n      fn(val, key, this);\n    }\n    return this;\n  }\n\n  /**\n   * Returns the first item(s) in the collection\n   */\n  first(): V | undefined;\n  first(amount: number): V[];\n  first(amount?: number): V | V[] | undefined {\n    if (amount === undefined) return this.values().next().value;\n    if (amount < 0) return this.last(amount * -1);\n    amount = Math.min(this.size, amount);\n    const iter = this.values();\n    return Array.from({ length: amount }, () => iter.next().value);\n  }\n\n  /**\n   * Returns the first key(s) in the collection\n   */\n  firstKey(): K | undefined;\n  firstKey(amount: number): K[];\n  firstKey(amount?: number): K | K[] | undefined {\n    if (amount === undefined) return this.keys().next().value;\n    if (amount < 0) return this.lastKey(amount * -1);\n    amount = Math.min(this.size, amount);\n    const iter = this.keys();\n    return Array.from({ length: amount }, () => iter.next().value);\n  }\n\n  /**\n   * Returns the last item(s) in the collection\n   */\n  last(): V | undefined;\n  last(amount: number): V[];\n  last(amount?: number): V | V[] | undefined {\n    const arr = [...this.values()];\n    if (amount === undefined) return arr[arr.length - 1];\n    if (amount < 0) return this.first(amount * -1);\n    if (!amount) return [];\n    return arr.slice(-amount);\n  }\n\n  /**\n   * Returns the last key(s) in the collection\n   */\n  lastKey(): K | undefined;\n  lastKey(amount: number): K[];\n  lastKey(amount?: number): K | K[] | undefined {\n    const arr = [...this.keys()];\n    if (amount === undefined) return arr[arr.length - 1];\n    if (amount < 0) return this.firstKey(amount * -1);\n    if (!amount) return [];\n    return arr.slice(-amount);\n  }\n\n  /**\n   * Returns a random item from the collection\n   */\n  random(): V | undefined;\n  random(amount: number): V[];\n  random(amount?: number): V | V[] | undefined {\n    const arr = [...this.values()];\n    if (amount === undefined) return arr[Math.floor(Math.random() * arr.length)];\n    if (!arr.length || !amount) return [];\n    return Array.from({ length: Math.min(amount, arr.length) }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);\n  }\n\n  /**\n   * Returns a random key from the collection\n   */\n  randomKey(): K | undefined;\n  randomKey(amount: number): K[];\n  randomKey(amount?: number): K | K[] | undefined {\n    const arr = [...this.keys()];\n    if (amount === undefined) return arr[Math.floor(Math.random() * arr.length)];\n    if (!arr.length || !amount) return [];\n    return Array.from({ length: Math.min(amount, arr.length) }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);\n  }\n\n  /**\n   * Combines this collection with others\n   */\n  concat(...collections: Collection<K, V>[]): Collection<K, V> {\n    const newColl = this.clone();\n    for (const coll of collections) {\n      for (const [key, val] of coll) newColl.set(key, val);\n    }\n    return newColl;\n  }\n\n  /**\n   * Checks if this collection shares identical items with another\n   */\n  equals(collection: Collection<K, V>): boolean {\n    if (this === collection) return true;\n    if (this.size !== collection.size) return false;\n    for (const [key, value] of this) {\n      if (!collection.has(key) || value !== collection.get(key)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Creates an identical shallow copy of this collection\n   */\n  clone(): Collection<K, V> {\n    return new Collection(this);\n  }\n\n  /**\n   * Sorts the collection and returns it\n   */\n  sort(compareFunction: (firstValue: V, secondValue: V, firstKey: K, secondKey: K) => number = Collection.defaultSort): this {\n    const entries = [...this.entries()];\n    entries.sort((a, b) => compareFunction(a[1], b[1], a[0], b[0]));\n    this.clear();\n    for (const [k, v] of entries) {\n      this.set(k, v);\n    }\n    return this;\n  }\n\n  /**\n   * Sorts the collection by keys and returns it\n   */\n  sortByKey(compareFunction: (firstKey: K, secondKey: K, firstValue: V, secondValue: V) => number = Collection.defaultSort): this {\n    const entries = [...this.entries()];\n    entries.sort((a, b) => compareFunction(a[0], b[0], a[1], b[1]));\n    this.clear();\n    for (const [k, v] of entries) {\n      this.set(k, v);\n    }\n    return this;\n  }\n\n  /**\n   * Returns an array of items\n   */\n  toJSON(): V[] {\n    return [...this.values()];\n  }\n\n  /**\n   * Default sort function\n   */\n  private static defaultSort<V>(firstValue: V, secondValue: V): number {\n    return Number(firstValue > secondValue) || Number(firstValue === secondValue) - 1;\n  }\n\n  /**\n   * Creates a Collection from an array\n   */\n  static from<K, V>(entries: Iterable<readonly [K, V]>): Collection<K, V> {\n    return new Collection(entries);\n  }\n}\n"]}