mirror of
https://github.com/musix-org/musix-oss
synced 2024-12-23 22:33:17 +00:00
389 lines
63 KiB
JavaScript
389 lines
63 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
/**
|
|
* A Map with additional utility methods. This is used throughout discord.js rather than Arrays for anything that has
|
|
* an ID, for significantly improved performance and ease-of-use.
|
|
* @extends {Map}
|
|
* @property {number} size - The amount of elements in this collection.
|
|
*/
|
|
class Collection extends Map {
|
|
constructor(entries) {
|
|
super(entries);
|
|
/**
|
|
* Cached array for the `array()` method - will be reset to `null` whenever `set()` or `delete()` are called
|
|
* @name Collection#_array
|
|
* @type {?Array}
|
|
* @private
|
|
*/
|
|
Object.defineProperty(this, '_array', { value: null, writable: true, configurable: true });
|
|
/**
|
|
* Cached array for the `keyArray()` method - will be reset to `null` whenever `set()` or `delete()` are called
|
|
* @name Collection#_keyArray
|
|
* @type {?Array}
|
|
* @private
|
|
*/
|
|
Object.defineProperty(this, '_keyArray', { value: null, writable: true, configurable: true });
|
|
}
|
|
/**
|
|
* Identical to [Map.get()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get).
|
|
* Gets an element with the specified key, and returns its value, or `undefined` if the element does not exist.
|
|
* @param {*} key - The key to get from this collection
|
|
* @returns {* | undefined}
|
|
*/
|
|
get(key) {
|
|
return super.get(key);
|
|
}
|
|
/**
|
|
* Identical to [Map.set()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set).
|
|
* Sets a new element in the collection with the specified key and value.
|
|
* @param {*} key - The key of the element to add
|
|
* @param {*} value - The value of the element to add
|
|
* @returns {Collection}
|
|
*/
|
|
set(key, value) {
|
|
this._array = null;
|
|
this._keyArray = null;
|
|
return super.set(key, value);
|
|
}
|
|
/**
|
|
* Identical to [Map.has()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has).
|
|
* Checks if an element exists in the collection.
|
|
* @param {*} key - The key of the element to check for
|
|
* @returns {boolean} `true` if the element exists, `false` if it does not exist.
|
|
*/
|
|
has(key) {
|
|
return super.has(key);
|
|
}
|
|
/**
|
|
* Identical to [Map.delete()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete).
|
|
* Deletes an element from the collection.
|
|
* @param {*} key - The key to delete from the collection
|
|
* @returns {boolean} `true` if the element was removed, `false` if the element does not exist.
|
|
*/
|
|
delete(key) {
|
|
this._array = null;
|
|
this._keyArray = null;
|
|
return super.delete(key);
|
|
}
|
|
/**
|
|
* Identical to [Map.clear()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear).
|
|
* Removes all elements from the collection.
|
|
* @returns {undefined}
|
|
*/
|
|
clear() {
|
|
return super.clear();
|
|
}
|
|
/**
|
|
* Creates an ordered array of the values of this collection, and caches it internally. The array will only be
|
|
* reconstructed if an item is added to or removed from the collection, or if you change the length of the array
|
|
* itself. If you don't want this caching behavior, use `[...collection.values()]` or
|
|
* `Array.from(collection.values())` instead.
|
|
* @returns {Array}
|
|
*/
|
|
array() {
|
|
if (!this._array || this._array.length !== this.size)
|
|
this._array = [...this.values()];
|
|
return this._array;
|
|
}
|
|
/**
|
|
* Creates an ordered array of the keys of this collection, and caches it internally. The array will only be
|
|
* reconstructed if an item is added to or removed from the collection, or if you change the length of the array
|
|
* itself. If you don't want this caching behavior, use `[...collection.keys()]` or
|
|
* `Array.from(collection.keys())` instead.
|
|
* @returns {Array}
|
|
*/
|
|
keyArray() {
|
|
if (!this._keyArray || this._keyArray.length !== this.size)
|
|
this._keyArray = [...this.keys()];
|
|
return this._keyArray;
|
|
}
|
|
first(amount) {
|
|
if (typeof 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 (typeof 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.array();
|
|
if (typeof 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.keyArray();
|
|
if (typeof amount === 'undefined')
|
|
return arr[arr.length - 1];
|
|
if (amount < 0)
|
|
return this.firstKey(amount * -1);
|
|
if (!amount)
|
|
return [];
|
|
return arr.slice(-amount);
|
|
}
|
|
random(amount) {
|
|
let arr = this.array();
|
|
if (typeof amount === 'undefined')
|
|
return arr[Math.floor(Math.random() * arr.length)];
|
|
if (arr.length === 0 || !amount)
|
|
return [];
|
|
arr = arr.slice();
|
|
return Array.from({ length: amount }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);
|
|
}
|
|
randomKey(amount) {
|
|
let arr = this.keyArray();
|
|
if (typeof amount === 'undefined')
|
|
return arr[Math.floor(Math.random() * arr.length)];
|
|
if (arr.length === 0 || !amount)
|
|
return [];
|
|
arr = arr.slice();
|
|
return Array.from({ length: amount }, () => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);
|
|
}
|
|
find(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
for (const [key, val] of this) {
|
|
if (fn(val, key, this))
|
|
return val;
|
|
}
|
|
return undefined;
|
|
}
|
|
findKey(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
for (const [key, val] of this) {
|
|
if (fn(val, key, this))
|
|
return key;
|
|
}
|
|
return undefined;
|
|
}
|
|
sweep(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
const previousSize = this.size;
|
|
for (const [key, val] of this) {
|
|
if (fn(val, key, this))
|
|
this.delete(key);
|
|
}
|
|
return previousSize - this.size;
|
|
}
|
|
filter(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
const results = new this.constructor[Symbol.species]();
|
|
for (const [key, val] of this) {
|
|
if (fn(val, key, this))
|
|
results.set(key, val);
|
|
}
|
|
return results;
|
|
}
|
|
partition(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
// TODO: consider removing the <K, V> from the constructors after TS 3.7.0 is released, as it infers it
|
|
const results = [new this.constructor[Symbol.species](), new this.constructor[Symbol.species]()];
|
|
for (const [key, val] of this) {
|
|
if (fn(val, key, this)) {
|
|
results[0].set(key, val);
|
|
}
|
|
else {
|
|
results[1].set(key, val);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
flatMap(fn, thisArg) {
|
|
const collections = this.map(fn, thisArg);
|
|
return new this.constructor[Symbol.species]().concat(...collections);
|
|
}
|
|
map(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
const iter = this.entries();
|
|
return Array.from({ length: this.size }, () => {
|
|
const [key, value] = iter.next().value;
|
|
return fn(value, key, this);
|
|
});
|
|
}
|
|
mapValues(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
const coll = new this.constructor[Symbol.species]();
|
|
for (const [key, val] of this)
|
|
coll.set(key, fn(val, key, this));
|
|
return coll;
|
|
}
|
|
some(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
for (const [key, val] of this) {
|
|
if (fn(val, key, this))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
every(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
for (const [key, val] of this) {
|
|
if (!fn(val, key, this))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Applies a function to produce a single value. Identical in behavior to
|
|
* [Array.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce).
|
|
* @param {Function} fn Function used to reduce, taking four arguments; `accumulator`, `currentValue`, `currentKey`,
|
|
* and `collection`
|
|
* @param {*} [initialValue] Starting value for the accumulator
|
|
* @returns {*}
|
|
* @example collection.reduce((acc, guild) => acc + guild.memberCount, 0);
|
|
*/
|
|
reduce(fn, initialValue) {
|
|
let accumulator;
|
|
if (typeof initialValue !== 'undefined') {
|
|
accumulator = initialValue;
|
|
for (const [key, val] of this)
|
|
accumulator = fn(accumulator, val, key, this);
|
|
return accumulator;
|
|
}
|
|
let first = true;
|
|
for (const [key, val] of this) {
|
|
if (first) {
|
|
accumulator = val;
|
|
first = false;
|
|
continue;
|
|
}
|
|
accumulator = fn(accumulator, val, key, this);
|
|
}
|
|
// No items iterated.
|
|
if (first) {
|
|
throw new TypeError('Reduce of empty collection with no initial value');
|
|
}
|
|
return accumulator;
|
|
}
|
|
each(fn, thisArg) {
|
|
this.forEach(fn, thisArg);
|
|
return this;
|
|
}
|
|
tap(fn, thisArg) {
|
|
if (typeof thisArg !== 'undefined')
|
|
fn = fn.bind(thisArg);
|
|
fn(this);
|
|
return this;
|
|
}
|
|
/**
|
|
* Creates an identical shallow copy of this collection.
|
|
* @returns {Collection}
|
|
* @example const newColl = someColl.clone();
|
|
*/
|
|
clone() {
|
|
return new this.constructor[Symbol.species](this);
|
|
}
|
|
/**
|
|
* Combines this collection with others into a new collection. None of the source collections are modified.
|
|
* @param {...Collection} collections Collections to merge
|
|
* @returns {Collection}
|
|
* @example const newColl = someColl.concat(someOtherColl, anotherColl, ohBoyAColl);
|
|
*/
|
|
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.
|
|
* This is different to checking for equality using equal-signs, because
|
|
* the collections may be different objects, but contain the same data.
|
|
* @param {Collection} collection Collection to compare with
|
|
* @returns {boolean} Whether the collections have identical contents
|
|
*/
|
|
equals(collection) {
|
|
if (!collection)
|
|
return false;
|
|
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;
|
|
}
|
|
/**
|
|
* The sort method sorts the items of a collection in place and returns it.
|
|
* The sort is not necessarily stable. The default sort order is according to string Unicode code points.
|
|
* @param {Function} [compareFunction] Specifies a function that defines the sort order.
|
|
* If omitted, the collection is sorted according to each character's Unicode code point value,
|
|
* according to the string conversion of each element.
|
|
* @returns {Collection}
|
|
* @example collection.sort((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);
|
|
*/
|
|
sort(compareFunction = (x, y) => Number(x > y) || Number(x === y) - 1) {
|
|
const entries = [...this.entries()];
|
|
entries.sort((a, b) => compareFunction(a[1], b[1], a[0], b[0]));
|
|
// Perform clean-up
|
|
super.clear();
|
|
this._array = null;
|
|
this._keyArray = null;
|
|
// Set the new entries
|
|
for (const [k, v] of entries) {
|
|
super.set(k, v);
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* The intersect method returns a new structure containing items where the keys are present in both original structures.
|
|
* @param {Collection} other The other Collection to filter against
|
|
* @returns {Collection}
|
|
*/
|
|
intersect(other) {
|
|
return other.filter((_, k) => this.has(k));
|
|
}
|
|
/**
|
|
* The difference method returns a new structure containing items where the key is present in one of the original structures but not the other.
|
|
* @param {Collection} other The other Collection to filter against
|
|
* @returns {Collection}
|
|
*/
|
|
difference(other) {
|
|
return other.filter((_, k) => !this.has(k)).concat(this.filter((_, k) => !other.has(k)));
|
|
}
|
|
/**
|
|
* The sorted method sorts the items of a collection and returns it.
|
|
* The sort is not necessarily stable. The default sort order is according to string Unicode code points.
|
|
* @param {Function} [compareFunction] Specifies a function that defines the sort order.
|
|
* If omitted, the collection is sorted according to each character's Unicode code point value,
|
|
* according to the string conversion of each element.
|
|
* @returns {Collection}
|
|
* @example collection.sorted((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);
|
|
*/
|
|
sorted(compareFunction = (x, y) => Number(x > y) || Number(x === y) - 1) {
|
|
return new this.constructor[Symbol.species]([...this.entries()])
|
|
.sort((av, bv, ak, bk) => compareFunction(av, bv, ak, bk));
|
|
}
|
|
}
|
|
exports.Collection = Collection;
|
|
Collection.default = Collection;
|
|
exports.default = Collection;
|
|
module.exports = Collection;
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"/","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["export interface CollectionConstructor {\n\tnew(): Collection<unknown, unknown>;\n\tnew<K, V>(entries?: ReadonlyArray<readonly [K, V]> | null): Collection<K, V>;\n\tnew<K, V>(iterable: Iterable<readonly [K, V]>): Collection<K, V>;\n\treadonly prototype: Collection<unknown, unknown>;\n\treadonly [Symbol.species]: CollectionConstructor;\n}\n\n/**\n * A Map with additional utility methods. This is used throughout discord.js rather than Arrays for anything that has\n * an ID, for significantly improved performance and ease-of-use.\n * @extends {Map}\n * @property {number} size - The amount of elements in this collection.\n */\nclass Collection<K, V> extends Map<K, V> {\n\tprivate _array!: V[] | null;\n\tprivate _keyArray!: K[] | null;\n\tpublic static readonly default: typeof Collection = Collection;\n\tpublic ['constructor']: typeof Collection;\n\n\tpublic constructor(entries?: ReadonlyArray<readonly [K, V]> | null) {\n\t\tsuper(entries);\n\n\t\t/**\n\t\t * Cached array for the `array()` method - will be reset to `null` whenever `set()` or `delete()` are called\n\t\t * @name Collection#_array\n\t\t * @type {?Array}\n\t\t * @private\n\t\t */\n\t\tObject.defineProperty(this, '_array', { value: null, writable: true, configurable: true });\n\n\t\t/**\n\t\t * Cached array for the `keyArray()` method - will be reset to `null` whenever `set()` or `delete()` are called\n\t\t * @name Collection#_keyArray\n\t\t * @type {?Array}\n\t\t * @private\n\t\t */\n\t\tObject.defineProperty(this, '_keyArray', { value: null, writable: true, configurable: true });\n\t}\n\n\t/**\n\t * Identical to [Map.get()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get).\n\t * Gets an element with the specified key, and returns its value, or `undefined` if the element does not exist.\n\t * @param {*} key - The key to get from this collection\n\t * @returns {* | undefined}\n\t */\n\tpublic get(key: K): V | undefined {\n\t\treturn super.get(key);\n\t}\n\n\t/**\n\t * Identical to [Map.set()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set).\n\t * Sets a new element in the collection with the specified key and value.\n\t * @param {*} key - The key of the element to add\n\t * @param {*} value - The value of the element to add\n\t * @returns {Collection}\n\t */\n\tpublic set(key: K, value: V): this {\n\t\tthis._array = null;\n\t\tthis._keyArray = null;\n\t\treturn super.set(key, value);\n\t}\n\n\t/**\n\t * Identical to [Map.has()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has).\n\t * Checks if an element exists in the collection.\n\t * @param {*} key - The key of the element to check for\n\t * @returns {boolean} `true` if the element exists, `false` if it does not exist.\n\t */\n\tpublic has(key: K): boolean {\n\t\treturn super.has(key);\n\t}\n\n\t/**\n\t * Identical to [Map.delete()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete).\n\t * Deletes an element from the collection.\n\t * @param {*} key - The key to delete from the collection\n\t * @returns {boolean} `true` if the element was removed, `false` if the element does not exist.\n\t */\n\tpublic delete(key: K): boolean {\n\t\tthis._array = null;\n\t\tthis._keyArray = null;\n\t\treturn super.delete(key);\n\t}\n\n\t/**\n\t * Identical to [Map.clear()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear).\n\t * Removes all elements from the collection.\n\t * @returns {undefined}\n\t */\n\tpublic clear(): void {\n\t\treturn super.clear();\n\t}\n\n\t/**\n\t * Creates an ordered array of the values of this collection, and caches it internally. The array will only be\n\t * reconstructed if an item is added to or removed from the collection, or if you change the length of the array\n\t * itself. If you don't want this caching behavior, use `[...collection.values()]` or\n\t * `Array.from(collection.values())` instead.\n\t * @returns {Array}\n\t */\n\tpublic array(): V[] {\n\t\tif (!this._array || this._array.length !== this.size) this._array = [...this.values()];\n\t\treturn this._array;\n\t}\n\n\t/**\n\t * Creates an ordered array of the keys of this collection, and caches it internally. The array will only be\n\t * reconstructed if an item is added to or removed from the collection, or if you change the length of the array\n\t * itself. If you don't want this caching behavior, use `[...collection.keys()]` or\n\t * `Array.from(collection.keys())` instead.\n\t * @returns {Array}\n\t */\n\tpublic keyArray(): K[] {\n\t\tif (!this._keyArray || this._keyArray.length !== this.size) this._keyArray = [...this.keys()];\n\t\treturn this._keyArray;\n\t}\n\n\t/**\n\t * Obtains the first value(s) in this collection.\n\t * @param {number} [amount] Amount of values to obtain from the beginning\n\t * @returns {*|Array<*>} A single value if no amount is provided or an array of values, starting from the end if\n\t * amount is negative\n\t */\n\tpublic first(): V | undefined;\n\tpublic first(amount: number): V[];\n\tpublic first(amount?: number): V | V[] | undefined {\n\t\tif (typeof amount === 'undefined') return this.values().next().value;\n\t\tif (amount < 0) return this.last(amount * -1);\n\t\tamount = Math.min(this.size, amount);\n\t\tconst iter = this.values();\n\t\treturn Array.from({ length: amount }, (): V => iter.next().value);\n\t}\n\n\t/**\n\t * Obtains the first key(s) in this collection.\n\t * @param {number} [amount] Amount of keys to obtain from the beginning\n\t * @returns {*|Array<*>} A single key if no amount is provided or an array of keys, starting from the end if\n\t * amount is negative\n\t */\n\tpublic firstKey(): K | undefined;\n\tpublic firstKey(amount: number): K[];\n\tpublic firstKey(amount?: number): K | K[] | undefined {\n\t\tif (typeof amount === 'undefined') return this.keys().next().value;\n\t\tif (amount < 0) return this.lastKey(amount * -1);\n\t\tamount = Math.min(this.size, amount);\n\t\tconst iter = this.keys();\n\t\treturn Array.from({ length: amount }, (): K => iter.next().value);\n\t}\n\n\t/**\n\t * Obtains the last value(s) in this collection. This relies on {@link Collection#array}, and thus the caching\n\t * mechanism applies here as well.\n\t * @param {number} [amount] Amount of values to obtain from the end\n\t * @returns {*|Array<*>} A single value if no amount is provided or an array of values, starting from the start if\n\t * amount is negative\n\t */\n\tpublic last(): V | undefined;\n\tpublic last(amount: number): V[];\n\tpublic last(amount?: number): V | V[] | undefined {\n\t\tconst arr = this.array();\n\t\tif (typeof amount === 'undefined') return arr[arr.length - 1];\n\t\tif (amount < 0) return this.first(amount * -1);\n\t\tif (!amount) return [];\n\t\treturn arr.slice(-amount);\n\t}\n\n\t/**\n\t * Obtains the last key(s) in this collection. This relies on {@link Collection#keyArray}, and thus the caching\n\t * mechanism applies here as well.\n\t * @param {number} [amount] Amount of keys to obtain from the end\n\t * @returns {*|Array<*>} A single key if no amount is provided or an array of keys, starting from the start if\n\t * amount is negative\n\t */\n\tpublic lastKey(): K | undefined;\n\tpublic lastKey(amount: number): K[];\n\tpublic lastKey(amount?: number): K | K[] | undefined {\n\t\tconst arr = this.keyArray();\n\t\tif (typeof amount === 'undefined') return arr[arr.length - 1];\n\t\tif (amount < 0) return this.firstKey(amount * -1);\n\t\tif (!amount) return [];\n\t\treturn arr.slice(-amount);\n\t}\n\n\t/**\n\t * Obtains unique random value(s) from this collection. This relies on {@link Collection#array}, and thus the caching\n\t * mechanism applies here as well.\n\t * @param {number} [amount] Amount of values to obtain randomly\n\t * @returns {*|Array<*>} A single value if no amount is provided or an array of values\n\t */\n\tpublic random(): V;\n\tpublic random(amount: number): V[];\n\tpublic random(amount?: number): V | V[] {\n\t\tlet arr = this.array();\n\t\tif (typeof amount === 'undefined') return arr[Math.floor(Math.random() * arr.length)];\n\t\tif (arr.length === 0 || !amount) return [];\n\t\tarr = arr.slice();\n\t\treturn Array.from({ length: amount }, (): V => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);\n\t}\n\n\t/**\n\t * Obtains unique random key(s) from this collection. This relies on {@link Collection#keyArray}, and thus the caching\n\t * mechanism applies here as well.\n\t * @param {number} [amount] Amount of keys to obtain randomly\n\t * @returns {*|Array<*>} A single key if no amount is provided or an array\n\t */\n\tpublic randomKey(): K;\n\tpublic randomKey(amount: number): K[];\n\tpublic randomKey(amount?: number): K | K[] {\n\t\tlet arr = this.keyArray();\n\t\tif (typeof amount === 'undefined') return arr[Math.floor(Math.random() * arr.length)];\n\t\tif (arr.length === 0 || !amount) return [];\n\t\tarr = arr.slice();\n\t\treturn Array.from({ length: amount }, (): K => arr.splice(Math.floor(Math.random() * arr.length), 1)[0]);\n\t}\n\n\t/**\n\t * Searches for a single item where the given function returns a truthy value. This behaves like\n\t * [Array.find()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find).\n\t * <warn>All collections used in Discord.js are mapped using their `id` property, and if you want to find by id you\n\t * should use the `get` method. See\n\t * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get) for details.</warn>\n\t * @param {Function} fn The function to test with (should return boolean)\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {*}\n\t * @example collection.find(user => user.username === 'Bob');\n\t */\n\tpublic find(fn: (value: V, key: K, collection: this) => boolean): V | undefined;\n\tpublic find<T>(fn: (this: T, value: V, key: K, collection: this) => boolean, thisArg: T): V | undefined;\n\tpublic find(fn: (value: V, key: K, collection: this) => boolean, thisArg?: unknown): V | undefined {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\tfor (const [key, val] of this) {\n\t\t\tif (fn(val, key, this)) return val;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Searches for the key of a single item where the given function returns a truthy value. This behaves like\n\t * [Array.findIndex()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex),\n\t * but returns the key rather than the positional index.\n\t * @param {Function} fn The function to test with (should return boolean)\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {*}\n\t * @example collection.findKey(user => user.username === 'Bob');\n\t */\n\tpublic findKey(fn: (value: V, key: K, collection: this) => boolean): K | undefined;\n\tpublic findKey<T>(fn: (this: T, value: V, key: K, collection: this) => boolean, thisArg: T): K | undefined;\n\tpublic findKey(fn: (value: V, key: K, collection: this) => boolean, thisArg?: unknown): K | undefined {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\tfor (const [key, val] of this) {\n\t\t\tif (fn(val, key, this)) return key;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Removes items that satisfy the provided filter function.\n\t * @param {Function} fn Function used to test (should return a boolean)\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {number} The number of removed entries\n\t */\n\tpublic sweep(fn: (value: V, key: K, collection: this) => boolean): number;\n\tpublic sweep<T>(fn: (this: T, value: V, key: K, collection: this) => boolean, thisArg: T): number;\n\tpublic sweep(fn: (value: V, key: K, collection: this) => boolean, thisArg?: unknown): number {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\tconst previousSize = this.size;\n\t\tfor (const [key, val] of this) {\n\t\t\tif (fn(val, key, this)) this.delete(key);\n\t\t}\n\t\treturn previousSize - this.size;\n\t}\n\n\t/**\n\t * Identical to\n\t * [Array.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),\n\t * but returns a Collection instead of an Array.\n\t * @param {Function} fn The function to test with (should return boolean)\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {Collection}\n\t * @example collection.filter(user => user.username === 'Bob');\n\t */\n\tpublic filter(fn: (value: V, key: K, collection: this) => boolean): this;\n\tpublic filter<T>(fn: (this: T, value: V, key: K, collection: this) => boolean, thisArg: T): this;\n\tpublic filter(fn: (value: V, key: K, collection: this) => boolean, thisArg?: unknown): this {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\tconst results = new this.constructor[Symbol.species]<K, V>() as this;\n\t\tfor (const [key, val] of this) {\n\t\t\tif (fn(val, key, this)) results.set(key, val);\n\t\t}\n\t\treturn results;\n\t}\n\n\t/**\n\t * Partitions the collection into two collections where the first collection\n\t * contains the items that passed and the second contains the items that failed.\n\t * @param {Function} fn Function used to test (should return a boolean)\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {Collection[]}\n\t * @example const [big, small] = collection.partition(guild => guild.memberCount > 250);\n\t */\n\tpublic partition(fn: (value: V, key: K, collection: this) => boolean): [this, this];\n\tpublic partition<T>(fn: (this: T, value: V, key: K, collection: this) => boolean, thisArg: T): [this, this];\n\tpublic partition(fn: (value: V, key: K, collection: this) => boolean, thisArg?: unknown): [this, this] {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\t// TODO: consider removing the <K, V> from the constructors after TS 3.7.0 is released, as it infers it\n\t\tconst results: [this, this] = [new this.constructor[Symbol.species]<K, V>() as this, new this.constructor[Symbol.species]<K, V>() as this];\n\t\tfor (const [key, val] of this) {\n\t\t\tif (fn(val, key, this)) {\n\t\t\t\tresults[0].set(key, val);\n\t\t\t} else {\n\t\t\t\tresults[1].set(key, val);\n\t\t\t}\n\t\t}\n\t\treturn results;\n\t}\n\n\t/**\n\t * Maps each item into a Collection, then joins the results into a single Collection. Identical in behavior to\n\t * [Array.flatMap()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap).\n\t * @param {Function} fn Function that produces a new Collection\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {Collection}\n\t * @example collection.flatMap(guild => guild.members);\n\t */\n\tpublic flatMap<T>(fn: (value: V, key: K, collection: this) => Collection<K, T>): Collection<K, T>;\n\tpublic flatMap<T, This>(fn: (this: This, value: V, key: K, collection: this) => Collection<K, T>, thisArg: This): Collection<K, T>;\n\tpublic flatMap<T>(fn: (value: V, key: K, collection: this) => Collection<K, T>, thisArg?: unknown): Collection<K, T> {\n\t\tconst collections = this.map(fn, thisArg);\n\t\treturn (new this.constructor[Symbol.species]<K, T>() as Collection<K, T>).concat(...collections);\n\t}\n\n\t/**\n\t * Maps each item to another value into an array. Identical in behavior to\n\t * [Array.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).\n\t * @param {Function} fn Function that produces an element of the new array, taking three arguments\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {Array}\n\t * @example collection.map(user => user.tag);\n\t */\n\tpublic map<T>(fn: (value: V, key: K, collection: this) => T): T[];\n\tpublic map<This, T>(fn: (this: This, value: V, key: K, collection: this) => T, thisArg: This): T[];\n\tpublic map<T>(fn: (value: V, key: K, collection: this) => T, thisArg?: unknown): T[] {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\tconst iter = this.entries();\n\t\treturn Array.from({ length: this.size }, (): T => {\n\t\t\tconst [key, value] = iter.next().value;\n\t\t\treturn fn(value, key, this);\n\t\t});\n\t}\n\n\t/**\n\t * Maps each item to another value into a collection. Identical in behavior to\n\t * [Array.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).\n\t * @param {Function} fn Function that produces an element of the new collection, taking three arguments\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {Collection}\n\t * @example collection.mapValues(user => user.tag);\n\t */\n\tpublic mapValues<T>(fn: (value: V, key: K, collection: this) => T): Collection<K, T>;\n\tpublic mapValues<This, T>(fn: (this: This, value: V, key: K, collection: this) => T, thisArg: This): Collection<K, T>;\n\tpublic mapValues<T>(fn: (value: V, key: K, collection: this) => T, thisArg?: unknown): Collection<K, T> {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\tconst coll = new this.constructor[Symbol.species]<K, T>() as Collection<K, T>;\n\t\tfor (const [key, val] of this) coll.set(key, fn(val, key, this));\n\t\treturn coll;\n\t}\n\n\t/**\n\t * Checks if there exists an item that passes a test. Identical in behavior to\n\t * [Array.some()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some).\n\t * @param {Function} fn Function used to test (should return a boolean)\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {boolean}\n\t * @example collection.some(user => user.discriminator === '0000');\n\t */\n\tpublic some(fn: (value: V, key: K, collection: this) => boolean): boolean;\n\tpublic some<T>(fn: (this: T, value: V, key: K, collection: this) => boolean, thisArg: T): boolean;\n\tpublic some(fn: (value: V, key: K, collection: this) => boolean, thisArg?: unknown): boolean {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\tfor (const [key, val] of this) {\n\t\t\tif (fn(val, key, this)) return true;\n\t\t}\n\t\treturn false;\n\t}\n\n\t/**\n\t * Checks if all items passes a test. Identical in behavior to\n\t * [Array.every()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every).\n\t * @param {Function} fn Function used to test (should return a boolean)\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {boolean}\n\t * @example collection.every(user => !user.bot);\n\t */\n\tpublic every(fn: (value: V, key: K, collection: this) => boolean): boolean;\n\tpublic every<T>(fn: (this: T, value: V, key: K, collection: this) => boolean, thisArg: T): boolean;\n\tpublic every(fn: (value: V, key: K, collection: this) => boolean, thisArg?: unknown): boolean {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\tfor (const [key, val] of this) {\n\t\t\tif (!fn(val, key, this)) return false;\n\t\t}\n\t\treturn true;\n\t}\n\n\t/**\n\t * Applies a function to produce a single value. Identical in behavior to\n\t * [Array.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce).\n\t * @param {Function} fn Function used to reduce, taking four arguments; `accumulator`, `currentValue`, `currentKey`,\n\t * and `collection`\n\t * @param {*} [initialValue] Starting value for the accumulator\n\t * @returns {*}\n\t * @example collection.reduce((acc, guild) => acc + guild.memberCount, 0);\n\t */\n\tpublic reduce<T>(fn: (accumulator: T, value: V, key: K, collection: this) => T, initialValue?: T): T {\n\t\tlet accumulator!: T;\n\n\t\tif (typeof initialValue !== 'undefined') {\n\t\t\taccumulator = initialValue;\n\t\t\tfor (const [key, val] of this) accumulator = fn(accumulator, val, key, this);\n\t\t\treturn accumulator;\n\t\t}\n\t\tlet first = true;\n\t\tfor (const [key, val] of this) {\n\t\t\tif (first) {\n\t\t\t\taccumulator = val as unknown as T;\n\t\t\t\tfirst = false;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\taccumulator = fn(accumulator, val, key, this);\n\t\t}\n\n\t\t// No items iterated.\n\t\tif (first) {\n\t\t\tthrow new TypeError('Reduce of empty collection with no initial value');\n\t\t}\n\n\t\treturn accumulator;\n\t}\n\n\t/**\n\t * Identical to\n\t * [Map.forEach()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach),\n\t * but returns the collection instead of undefined.\n\t * @param {Function} fn Function to execute for each element\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {Collection}\n\t * @example\n\t * collection\n\t *  .each(user => console.log(user.username))\n\t *  .filter(user => user.bot)\n\t *  .each(user => console.log(user.username));\n\t */\n\tpublic each(fn: (value: V, key: K, collection: this) => void): this;\n\tpublic each<T>(fn: (this: T, value: V, key: K, collection: this) => void, thisArg: T): this;\n\tpublic each(fn: (value: V, key: K, collection: this) => void, thisArg?: unknown): this {\n\t\tthis.forEach(fn as (value: V, key: K, map: Map<K, V>) => void, thisArg);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Runs a function on the collection and returns the collection.\n\t * @param {Function} fn Function to execute\n\t * @param {*} [thisArg] Value to use as `this` when executing function\n\t * @returns {Collection}\n\t * @example\n\t * collection\n\t *  .tap(coll => console.log(coll.size))\n\t *  .filter(user => user.bot)\n\t *  .tap(coll => console.log(coll.size))\n\t */\n\tpublic tap(fn: (collection: this) => void): this;\n\tpublic tap<T>(fn: (this: T, collection: this) => void, thisArg: T): this;\n\tpublic tap(fn: (collection: this) => void, thisArg?: unknown): this {\n\t\tif (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);\n\t\tfn(this);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Creates an identical shallow copy of this collection.\n\t * @returns {Collection}\n\t * @example const newColl = someColl.clone();\n\t */\n\tpublic clone(): this {\n\t\treturn new this.constructor[Symbol.species](this) as this;\n\t}\n\n\t/**\n\t * Combines this collection with others into a new collection. None of the source collections are modified.\n\t * @param {...Collection} collections Collections to merge\n\t * @returns {Collection}\n\t * @example const newColl = someColl.concat(someOtherColl, anotherColl, ohBoyAColl);\n\t */\n\tpublic concat(...collections: Collection<K, V>[]): this {\n\t\tconst newColl = this.clone();\n\t\tfor (const coll of collections) {\n\t\t\tfor (const [key, val] of coll) newColl.set(key, val);\n\t\t}\n\t\treturn newColl;\n\t}\n\n\t/**\n\t * Checks if this collection shares identical items with another.\n\t * This is different to checking for equality using equal-signs, because\n\t * the collections may be different objects, but contain the same data.\n\t * @param {Collection} collection Collection to compare with\n\t * @returns {boolean} Whether the collections have identical contents\n\t */\n\tpublic equals(collection: Collection<K, V>): boolean {\n\t\tif (!collection) return false;\n\t\tif (this === collection) return true;\n\t\tif (this.size !== collection.size) return false;\n\t\tfor (const [key, value] of this) {\n\t\t\tif (!collection.has(key) || value !== collection.get(key)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\n\t/**\n\t * The sort method sorts the items of a collection in place and returns it.\n\t * The sort is not necessarily stable. The default sort order is according to string Unicode code points.\n\t * @param {Function} [compareFunction] Specifies a function that defines the sort order.\n\t * If omitted, the collection is sorted according to each character's Unicode code point value,\n\t * according to the string conversion of each element.\n\t * @returns {Collection}\n\t * @example collection.sort((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);\n\t */\n\tpublic sort(compareFunction: (firstValue: V, secondValue: V, firstKey: K, secondKey: K) => number = (x, y): number => Number(x > y) || Number(x === y) - 1): this {\n\t\tconst entries = [...this.entries()];\n\t\tentries.sort((a, b): number => compareFunction(a[1], b[1], a[0], b[0]));\n\n\t\t// Perform clean-up\n\t\tsuper.clear();\n\t\tthis._array = null;\n\t\tthis._keyArray = null;\n\n\t\t// Set the new entries\n\t\tfor (const [k, v] of entries) {\n\t\t\tsuper.set(k, v);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * The intersect method returns a new structure containing items where the keys are present in both original structures.\n\t * @param {Collection} other The other Collection to filter against\n\t * @returns {Collection}\n\t */\n\tpublic intersect(other: Collection<K, V>): Collection<K, V> {\n\t\treturn other.filter((_, k) => this.has(k));\n\t}\n\n\t/**\n\t * The difference method returns a new structure containing items where the key is present in one of the original structures but not the other.\n\t * @param {Collection} other The other Collection to filter against\n\t * @returns {Collection}\n\t */\n\tpublic difference(other: Collection<K, V>): Collection<K, V> {\n\t\treturn other.filter((_, k) => !this.has(k)).concat(this.filter((_, k) => !other.has(k)));\n\t}\n\n\t/**\n\t * The sorted method sorts the items of a collection and returns it.\n\t * The sort is not necessarily stable. The default sort order is according to string Unicode code points.\n\t * @param {Function} [compareFunction] Specifies a function that defines the sort order.\n\t * If omitted, the collection is sorted according to each character's Unicode code point value,\n\t * according to the string conversion of each element.\n\t * @returns {Collection}\n\t * @example collection.sorted((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);\n\t */\n\tpublic sorted(compareFunction: (firstValue: V, secondValue: V, firstKey: K, secondKey: K) => number = (x, y): number => Number(x > y) || Number(x === y) - 1): this {\n\t\treturn (new this.constructor[Symbol.species]([...this.entries()]) as this)\n\t\t\t.sort((av, bv, ak, bk) => compareFunction(av, bv, ak, bk));\n\t}\n}\n\nexport { Collection };\nexport default Collection;\nmodule.exports = Collection;\n"]}
|