beniocord.js 2.0.8 → 2.0.9

package/helpers/index.js

@@ -1,6 +1,6 @@
 function formatUrl(url) {
     const base = 'https://api.beniocord.site';
-    if (!url) return undefined;
+    if (!url) return null;
     if (url.startsWith(base) || url.startsWith('http')) return url;
     return base + (url.startsWith('/') ? url : '/' + url);
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "dependencies": {
+    "@discordjs/collection": "^2.1.1",
     "axios": "^1.12.2",
     "socket.io-client": "^4.8.1"
   },
   "name": "beniocord.js",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "description": "Uma biblioteca leve e intuitiva para integração com APIs de bots em plataformas de mensagens, como Discord. Facilita o envio de mensagens, gerenciamento de canais e interação com usuários, proporcionando uma experiência de desenvolvimento ágil e eficiente.",
   "main": "Client.js",
-  "devDependencies": {},
   "scripts": {
     "test": "node bot.js"
   },

package/structures/Channel.js

@@ -1,6 +1,6 @@
 const { formatUrl } = require('../helpers');
 const MessageCollector = require('./MessageCollector');
-const Collection = require('../collection').Collection;
+const Collection = require('@discordjs/collection').Collection;
 
 let client;
 class Channel {
@@ -8,16 +8,16 @@ class Channel {
     client = clientInstance;
 
     this.id = data.id;
-    this.ownerId = data.created_by;
     this.name = data.name;
     this.description = data.description;
     this.type = data.type || "text";
+    this.iconUrl = formatUrl(data.icon_url) || null;
+    this.ownerId = data.created_by;
     this.isPrivate = data.is_private;
     this.isLocked = data.is_locked;
-    this.iconUrl = formatUrl(data.icon_url) || null;
+    this.memberCount = Number(data.member_count);
     this.createdAt = data.created_at;
     this.updatedAt = data.updated_at;
-    this.memberCount = data.member_count;
 
     this.members = new Collection();
     this.members.fetch = async () => {

package/structures/Message.js

@@ -11,12 +11,11 @@ class Message {
     this.fileUrl = formatUrl(data.file_url);
     this.fileName = data.file_name;
     this.fileSize = data.file_size;
+    this.attachments = [];
     this.replyTo = data.reply_to;
+    this.stickerId = data.sticker_id;
     this.editedAt = data.edited_at;
     this.createdAt = data.created_at;
-    this.stickerId = data.sticker_id;
-
-    this.attachments = [];
 
     if (data.file_url) {
       this.attachments.push({

package/structures/User.js

@@ -8,9 +8,9 @@ class User {
     this.avatarUrl = formatUrl(data.avatar_url);
     this.status = data.status || "offline";
     this.emblems = data.emblems || [];
+    this.isBot = data.is_bot;
     this.lastSeen = data.last_seen;
     this.createdAt = data.created_at;
-    this.isBot = data.is_bot;
     // this.email = data.email;
     // this.updatedAt = data.updated_at;
   }

package/collection/index.d.ts

@@ -1,457 +0,0 @@
-/**
- * @internal
- */
-interface CollectionConstructor {
-    new (): Collection<unknown, unknown>;
-    new <K, V>(entries?: readonly (readonly [K, V])[] | null): Collection<K, V>;
-    new <K, V>(iterable: Iterable<readonly [K, V]>): Collection<K, V>;
-    readonly prototype: Collection<unknown, unknown>;
-    readonly [Symbol.species]: CollectionConstructor;
-}
-/**
- * Represents an immutable version of a collection
- */
-type ReadonlyCollection<K, V> = Omit<Collection<K, V>, 'delete' | 'ensure' | 'forEach' | 'get' | 'reverse' | 'set' | 'sort' | 'sweep'> & ReadonlyMap<K, V>;
-/**
- * Separate interface for the constructor so that emitted js does not have a constructor that overwrites itself
- *
- * @internal
- */
-interface Collection<K, V> extends Map<K, V> {
-    constructor: CollectionConstructor;
-}
-/**
- * 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.
- *
- * @typeParam K - The key type this collection holds
- * @typeParam V - The value type this collection holds
- */
-declare class Collection<K, V> extends Map<K, V> {
-    /**
-     * Obtains the value of the given key if it exists, otherwise sets and returns the value provided by the default value generator.
-     *
-     * @param key - The key to get if it exists, or set otherwise
-     * @param defaultValueGenerator - A function that generates the default value
-     * @example
-     * ```ts
-     * collection.ensure(guildId, () => defaultGuildConfig);
-     * ```
-     */
-    ensure(key: K, defaultValueGenerator: (key: K, collection: this) => V): V;
-    /**
-     * Checks if all of the elements exist in the collection.
-     *
-     * @param keys - The keys of the elements to check for
-     * @returns `true` if all of the elements exist, `false` if at least one does not exist.
-     */
-    hasAll(...keys: K[]): boolean;
-    /**
-     * Checks if any of the elements exist in the collection.
-     *
-     * @param keys - The keys of the elements to check for
-     * @returns `true` if any of the elements exist, `false` if none exist.
-     */
-    hasAny(...keys: K[]): boolean;
-    /**
-     * Obtains the first value(s) in this collection.
-     *
-     * @param amount - Amount of values to obtain from the beginning
-     * @returns A single value if no amount is provided or an array of values, starting from the end if amount is negative
-     */
-    first(): V | undefined;
-    first(amount: number): V[];
-    /**
-     * Obtains the first key(s) in this collection.
-     *
-     * @param amount - Amount of keys to obtain from the beginning
-     * @returns A single key if no amount is provided or an array of keys, starting from the end if
-     * amount is negative
-     */
-    firstKey(): K | undefined;
-    firstKey(amount: number): K[];
-    /**
-     * Obtains the last value(s) in this collection.
-     *
-     * @param amount - Amount of values to obtain from the end
-     * @returns A single value if no amount is provided or an array of values, starting from the start if
-     * amount is negative
-     */
-    last(): V | undefined;
-    last(amount: number): V[];
-    /**
-     * Obtains the last key(s) in this collection.
-     *
-     * @param amount - Amount of keys to obtain from the end
-     * @returns A single key if no amount is provided or an array of keys, starting from the start if
-     * amount is negative
-     */
-    lastKey(): K | undefined;
-    lastKey(amount: number): K[];
-    /**
-     * Identical to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at()}.
-     * Returns the item at a given index, allowing for positive and negative integers.
-     * Negative integers count back from the last item in the collection.
-     *
-     * @param index - The index of the element to obtain
-     */
-    at(index: number): V | undefined;
-    /**
-     * Identical to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at()}.
-     * Returns the key at a given index, allowing for positive and negative integers.
-     * Negative integers count back from the last item in the collection.
-     *
-     * @param index - The index of the key to obtain
-     */
-    keyAt(index: number): K | undefined;
-    /**
-     * Obtains unique random value(s) from this collection.
-     *
-     * @param amount - Amount of values to obtain randomly
-     * @returns A single value if no amount is provided or an array of values
-     */
-    random(): V | undefined;
-    random(amount: number): V[];
-    /**
-     * Obtains unique random key(s) from this collection.
-     *
-     * @param amount - Amount of keys to obtain randomly
-     * @returns A single key if no amount is provided or an array
-     */
-    randomKey(): K | undefined;
-    randomKey(amount: number): K[];
-    /**
-     * Identical to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse | Array.reverse()}
-     * but returns a Collection instead of an Array.
-     */
-    reverse(): this;
-    /**
-     * Searches for a single item where the given function returns a truthy value. This behaves like
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find | Array.find()}.
-     * All collections used in Discord.js are mapped using their `id` property, and if you want to find by id you
-     * should use the `get` method. See
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get | MDN} for details.
-     *
-     * @param fn - The function to test with (should return boolean)
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection.find(user => user.username === 'Bob');
-     * ```
-     */
-    find<V2 extends V>(fn: (value: V, key: K, collection: this) => value is V2): V2 | undefined;
-    find(fn: (value: V, key: K, collection: this) => unknown): V | undefined;
-    find<This, V2 extends V>(fn: (this: This, value: V, key: K, collection: this) => value is V2, thisArg: This): V2 | undefined;
-    find<This>(fn: (this: This, value: V, key: K, collection: this) => unknown, thisArg: This): V | undefined;
-    /**
-     * Searches for the key of a single item where the given function returns a truthy value. This behaves like
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex | Array.findIndex()},
-     * but returns the key rather than the positional index.
-     *
-     * @param fn - The function to test with (should return boolean)
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection.findKey(user => user.username === 'Bob');
-     * ```
-     */
-    findKey<K2 extends K>(fn: (value: V, key: K, collection: this) => key is K2): K2 | undefined;
-    findKey(fn: (value: V, key: K, collection: this) => unknown): K | undefined;
-    findKey<This, K2 extends K>(fn: (this: This, value: V, key: K, collection: this) => key is K2, thisArg: This): K2 | undefined;
-    findKey<This>(fn: (this: This, value: V, key: K, collection: this) => unknown, thisArg: This): K | undefined;
-    /**
-     * Removes items that satisfy the provided filter function.
-     *
-     * @param fn - Function used to test (should return a boolean)
-     * @param thisArg - Value to use as `this` when executing function
-     * @returns The number of removed entries
-     */
-    sweep(fn: (value: V, key: K, collection: this) => unknown): number;
-    sweep<T>(fn: (this: T, value: V, key: K, collection: this) => unknown, thisArg: T): number;
-    /**
-     * Identical to
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter | Array.filter()},
-     * but returns a Collection instead of an Array.
-     *
-     * @param fn - The function to test with (should return boolean)
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection.filter(user => user.username === 'Bob');
-     * ```
-     */
-    filter<K2 extends K>(fn: (value: V, key: K, collection: this) => key is K2): Collection<K2, V>;
-    filter<V2 extends V>(fn: (value: V, key: K, collection: this) => value is V2): Collection<K, V2>;
-    filter(fn: (value: V, key: K, collection: this) => unknown): Collection<K, V>;
-    filter<This, K2 extends K>(fn: (this: This, value: V, key: K, collection: this) => key is K2, thisArg: This): Collection<K2, V>;
-    filter<This, V2 extends V>(fn: (this: This, value: V, key: K, collection: this) => value is V2, thisArg: This): Collection<K, V2>;
-    filter<This>(fn: (this: This, value: V, key: K, collection: this) => unknown, thisArg: This): Collection<K, V>;
-    /**
-     * Partitions the collection into two collections where the first collection
-     * contains the items that passed and the second contains the items that failed.
-     *
-     * @param fn - Function used to test (should return a boolean)
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * const [big, small] = collection.partition(guild => guild.memberCount > 250);
-     * ```
-     */
-    partition<K2 extends K>(fn: (value: V, key: K, collection: this) => key is K2): [Collection<K2, V>, Collection<Exclude<K, K2>, V>];
-    partition<V2 extends V>(fn: (value: V, key: K, collection: this) => value is V2): [Collection<K, V2>, Collection<K, Exclude<V, V2>>];
-    partition(fn: (value: V, key: K, collection: this) => unknown): [Collection<K, V>, Collection<K, V>];
-    partition<This, K2 extends K>(fn: (this: This, value: V, key: K, collection: this) => key is K2, thisArg: This): [Collection<K2, V>, Collection<Exclude<K, K2>, V>];
-    partition<This, V2 extends V>(fn: (this: This, value: V, key: K, collection: this) => value is V2, thisArg: This): [Collection<K, V2>, Collection<K, Exclude<V, V2>>];
-    partition<This>(fn: (this: This, value: V, key: K, collection: this) => unknown, thisArg: This): [Collection<K, V>, Collection<K, V>];
-    /**
-     * Maps each item into a Collection, then joins the results into a single Collection. Identical in behavior to
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap | Array.flatMap()}.
-     *
-     * @param fn - Function that produces a new Collection
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection.flatMap(guild => guild.members.cache);
-     * ```
-     */
-    flatMap<T>(fn: (value: V, key: K, collection: this) => Collection<K, T>): Collection<K, T>;
-    flatMap<T, This>(fn: (this: This, value: V, key: K, collection: this) => Collection<K, T>, thisArg: This): Collection<K, T>;
-    /**
-     * Maps each item to another value into an array. Identical in behavior to
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map | Array.map()}.
-     *
-     * @param fn - Function that produces an element of the new array, taking three arguments
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection.map(user => user.tag);
-     * ```
-     */
-    map<T>(fn: (value: V, key: K, collection: this) => T): T[];
-    map<This, T>(fn: (this: This, value: V, key: K, collection: this) => T, thisArg: This): T[];
-    /**
-     * Maps each item to another value into a collection. Identical in behavior to
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map | Array.map()}.
-     *
-     * @param fn - Function that produces an element of the new collection, taking three arguments
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection.mapValues(user => user.tag);
-     * ```
-     */
-    mapValues<T>(fn: (value: V, key: K, collection: this) => T): Collection<K, T>;
-    mapValues<This, T>(fn: (this: This, value: V, key: K, collection: this) => T, thisArg: This): Collection<K, T>;
-    /**
-     * Checks if there exists an item that passes a test. Identical in behavior to
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some | Array.some()}.
-     *
-     * @param fn - Function used to test (should return a boolean)
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection.some(user => user.discriminator === '0000');
-     * ```
-     */
-    some(fn: (value: V, key: K, collection: this) => unknown): boolean;
-    some<T>(fn: (this: T, value: V, key: K, collection: this) => unknown, thisArg: T): boolean;
-    /**
-     * Checks if all items passes a test. Identical in behavior to
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every | Array.every()}.
-     *
-     * @param fn - Function used to test (should return a boolean)
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection.every(user => !user.bot);
-     * ```
-     */
-    every<K2 extends K>(fn: (value: V, key: K, collection: this) => key is K2): this is Collection<K2, V>;
-    every<V2 extends V>(fn: (value: V, key: K, collection: this) => value is V2): this is Collection<K, V2>;
-    every(fn: (value: V, key: K, collection: this) => unknown): boolean;
-    every<This, K2 extends K>(fn: (this: This, value: V, key: K, collection: this) => key is K2, thisArg: This): this is Collection<K2, V>;
-    every<This, V2 extends V>(fn: (this: This, value: V, key: K, collection: this) => value is V2, thisArg: This): this is Collection<K, V2>;
-    every<This>(fn: (this: This, value: V, key: K, collection: this) => unknown, thisArg: This): boolean;
-    /**
-     * Applies a function to produce a single value. Identical in behavior to
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce | Array.reduce()}.
-     *
-     * @param fn - Function used to reduce, taking four arguments; `accumulator`, `currentValue`, `currentKey`,
-     * and `collection`
-     * @param initialValue - Starting value for the accumulator
-     * @example
-     * ```ts
-     * collection.reduce((acc, guild) => acc + guild.memberCount, 0);
-     * ```
-     */
-    reduce<T = V>(fn: (accumulator: T, value: V, key: K, collection: this) => T, initialValue?: T): T;
-    /**
-     * Identical to
-     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach | Map.forEach()},
-     * but returns the collection instead of undefined.
-     *
-     * @param fn - Function to execute for each element
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection
-     *  .each(user => console.log(user.username))
-     *  .filter(user => user.bot)
-     *  .each(user => console.log(user.username));
-     * ```
-     */
-    each(fn: (value: V, key: K, collection: this) => void): this;
-    each<T>(fn: (this: T, value: V, key: K, collection: this) => void, thisArg: T): this;
-    /**
-     * Runs a function on the collection and returns the collection.
-     *
-     * @param fn - Function to execute
-     * @param thisArg - Value to use as `this` when executing function
-     * @example
-     * ```ts
-     * collection
-     *  .tap(coll => console.log(coll.size))
-     *  .filter(user => user.bot)
-     *  .tap(coll => console.log(coll.size))
-     * ```
-     */
-    tap(fn: (collection: this) => void): this;
-    tap<T>(fn: (this: T, collection: this) => void, thisArg: T): this;
-    /**
-     * Creates an identical shallow copy of this collection.
-     *
-     * @example
-     * ```ts
-     * const newColl = someColl.clone();
-     * ```
-     */
-    clone(): Collection<K, V>;
-    /**
-     * Combines this collection with others into a new collection. None of the source collections are modified.
-     *
-     * @param collections - Collections to merge
-     * @example
-     * ```ts
-     * const newColl = someColl.concat(someOtherColl, anotherColl, ohBoyAColl);
-     * ```
-     */
-    concat(...collections: ReadonlyCollection<K, V>[]): Collection<K, V>;
-    /**
-     * 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 to compare with
-     * @returns Whether the collections have identical contents
-     */
-    equals(collection: ReadonlyCollection<K, V>): boolean;
-    /**
-     * The sort method sorts the items of a collection in place and returns it.
-     * The sort is not necessarily stable in Node 10 or older.
-     * The default sort order is according to string Unicode code points.
-     *
-     * @param 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.
-     * @example
-     * ```ts
-     * collection.sort((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);
-     * ```
-     */
-    sort(compareFunction?: Comparator<K, V>): this;
-    /**
-     * The intersect method returns a new structure containing items where the keys and values are present in both original structures.
-     *
-     * @param other - The other Collection to filter against
-     */
-    intersect<T>(other: ReadonlyCollection<K, T>): Collection<K, T>;
-    /**
-     * The subtract method returns a new structure containing items where the keys and values of the original structure are not present in the other.
-     *
-     * @param other - The other Collection to filter against
-     */
-    subtract<T>(other: ReadonlyCollection<K, T>): Collection<K, V>;
-    /**
-     * 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 other - The other Collection to filter against
-     */
-    difference<T>(other: ReadonlyCollection<K, T>): Collection<K, T | V>;
-    /**
-     * Merges two Collections together into a new Collection.
-     *
-     * @param other - The other Collection to merge with
-     * @param whenInSelf - Function getting the result if the entry only exists in this Collection
-     * @param whenInOther - Function getting the result if the entry only exists in the other Collection
-     * @param whenInBoth - Function getting the result if the entry exists in both Collections
-     * @example
-     * ```ts
-     * // Sums up the entries in two collections.
-     * coll.merge(
-     *  other,
-     *  x => ({ keep: true, value: x }),
-     *  y => ({ keep: true, value: y }),
-     *  (x, y) => ({ keep: true, value: x + y }),
-     * );
-     * ```
-     * @example
-     * ```ts
-     * // Intersects two collections in a left-biased manner.
-     * coll.merge(
-     *  other,
-     *  x => ({ keep: false }),
-     *  y => ({ keep: false }),
-     *  (x, _) => ({ keep: true, value: x }),
-     * );
-     * ```
-     */
-    merge<T, R>(other: ReadonlyCollection<K, T>, whenInSelf: (value: V, key: K) => Keep<R>, whenInOther: (valueOther: T, key: K) => Keep<R>, whenInBoth: (value: V, valueOther: T, key: K) => Keep<R>): Collection<K, R>;
-    /**
-     * The sorted method sorts the items of a collection and returns it.
-     * The sort is not necessarily stable in Node 10 or older.
-     * The default sort order is according to string Unicode code points.
-     *
-     * @param 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.
-     * @example
-     * ```ts
-     * collection.sorted((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);
-     * ```
-     */
-    sorted(compareFunction?: Comparator<K, V>): Collection<K, V>;
-    toJSON(): V[];
-    private static defaultSort;
-    /**
-     * Creates a Collection from a list of entries.
-     *
-     * @param entries - The list of entries
-     * @param combine - Function to combine an existing entry with a new one
-     * @example
-     * ```ts
-     * Collection.combineEntries([["a", 1], ["b", 2], ["a", 2]], (x, y) => x + y);
-     * // returns Collection { "a" => 3, "b" => 2 }
-     * ```
-     */
-    static combineEntries<K, V>(entries: Iterable<[K, V]>, combine: (firstValue: V, secondValue: V, key: K) => V): Collection<K, V>;
-}
-/**
- * @internal
- */
-type Keep<V> = {
-    keep: false;
-} | {
-    keep: true;
-    value: V;
-};
-/**
- * @internal
- */
-type Comparator<K, V> = (firstValue: V, secondValue: V, firstKey: K, secondKey: K) => number;
-
-/**
- * The {@link https://github.com/discordjs/discord.js/blob/main/packages/collection/#readme | @discordjs/collection} version
- * that you are currently using.
- */
-declare const version: string;
-
-export { Collection, CollectionConstructor, Comparator, Keep, ReadonlyCollection, version };

package/collection/index.js

@@ -1,543 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Collection: () => Collection,
-  version: () => version
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/collection.ts
-var Collection = class _Collection extends Map {
-  static {
-    __name(this, "Collection");
-  }
-  /**
-   * Obtains the value of the given key if it exists, otherwise sets and returns the value provided by the default value generator.
-   *
-   * @param key - The key to get if it exists, or set otherwise
-   * @param defaultValueGenerator - A function that generates the default value
-   * @example
-   * ```ts
-   * collection.ensure(guildId, () => defaultGuildConfig);
-   * ```
-   */
-  ensure(key, defaultValueGenerator) {
-    if (this.has(key))
-      return this.get(key);
-    if (typeof defaultValueGenerator !== "function")
-      throw new TypeError(`${defaultValueGenerator} is not a function`);
-    const defaultValue = defaultValueGenerator(key, this);
-    this.set(key, defaultValue);
-    return defaultValue;
-  }
-  /**
-   * Checks if all of the elements exist in the collection.
-   *
-   * @param keys - The keys of the elements to check for
-   * @returns `true` if all of the elements exist, `false` if at least one does not exist.
-   */
-  hasAll(...keys) {
-    return keys.every((key) => super.has(key));
-  }
-  /**
-   * Checks if any of the elements exist in the collection.
-   *
-   * @param keys - The keys of the elements to check for
-   * @returns `true` if any of the elements exist, `false` if none exist.
-   */
-  hasAny(...keys) {
-    return keys.some((key) => super.has(key));
-  }
-  first(amount) {
-    if (amount === void 0)
-      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 === void 0)
-      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 === void 0)
-      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 === void 0)
-      return arr[arr.length - 1];
-    if (amount < 0)
-      return this.firstKey(amount * -1);
-    if (!amount)
-      return [];
-    return arr.slice(-amount);
-  }
-  /**
-   * Identical to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at()}.
-   * Returns the item at a given index, allowing for positive and negative integers.
-   * Negative integers count back from the last item in the collection.
-   *
-   * @param index - The index of the element to obtain
-   */
-  at(index) {
-    index = Math.floor(index);
-    const arr = [...this.values()];
-    return arr.at(index);
-  }
-  /**
-   * Identical to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at()}.
-   * Returns the key at a given index, allowing for positive and negative integers.
-   * Negative integers count back from the last item in the collection.
-   *
-   * @param index - The index of the key to obtain
-   */
-  keyAt(index) {
-    index = Math.floor(index);
-    const arr = [...this.keys()];
-    return arr.at(index);
-  }
-  random(amount) {
-    const arr = [...this.values()];
-    if (amount === void 0)
-      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 === void 0)
-      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]
-    );
-  }
-  /**
-   * Identical to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse | Array.reverse()}
-   * but returns a Collection instead of an Array.
-   */
-  reverse() {
-    const entries = [...this.entries()].reverse();
-    this.clear();
-    for (const [key, value] of entries)
-      this.set(key, value);
-    return this;
-  }
-  find(fn, thisArg) {
-    if (typeof fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      fn = fn.bind(thisArg);
-    for (const [key, val] of this) {
-      if (fn(val, key, this))
-        return val;
-    }
-    return void 0;
-  }
-  findKey(fn, thisArg) {
-    if (typeof fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      fn = fn.bind(thisArg);
-    for (const [key, val] of this) {
-      if (fn(val, key, this))
-        return key;
-    }
-    return void 0;
-  }
-  sweep(fn, thisArg) {
-    if (typeof fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      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 fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      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 fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      fn = fn.bind(thisArg);
-    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 fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      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 fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      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 fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      fn = fn.bind(thisArg);
-    for (const [key, val] of this) {
-      if (fn(val, key, this))
-        return true;
-    }
-    return false;
-  }
-  every(fn, thisArg) {
-    if (typeof fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      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
-   * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce | Array.reduce()}.
-   *
-   * @param fn - Function used to reduce, taking four arguments; `accumulator`, `currentValue`, `currentKey`,
-   * and `collection`
-   * @param initialValue - Starting value for the accumulator
-   * @example
-   * ```ts
-   * collection.reduce((acc, guild) => acc + guild.memberCount, 0);
-   * ```
-   */
-  reduce(fn, initialValue) {
-    if (typeof fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    let accumulator;
-    const iterator = this.entries();
-    if (initialValue === void 0) {
-      if (this.size === 0)
-        throw new TypeError("Reduce of empty collection with no initial value");
-      accumulator = iterator.next().value[1];
-    } else {
-      accumulator = initialValue;
-    }
-    for (const [key, value] of iterator) {
-      accumulator = fn(accumulator, value, key, this);
-    }
-    return accumulator;
-  }
-  each(fn, thisArg) {
-    if (typeof fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      fn = fn.bind(thisArg);
-    for (const [key, value] of this) {
-      fn(value, key, this);
-    }
-    return this;
-  }
-  tap(fn, thisArg) {
-    if (typeof fn !== "function")
-      throw new TypeError(`${fn} is not a function`);
-    if (thisArg !== void 0)
-      fn = fn.bind(thisArg);
-    fn(this);
-    return this;
-  }
-  /**
-   * Creates an identical shallow copy of this collection.
-   *
-   * @example
-   * ```ts
-   * 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 collections - Collections to merge
-   * @example
-   * ```ts
-   * 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 to compare with
-   * @returns 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 in Node 10 or older.
-   * The default sort order is according to string Unicode code points.
-   *
-   * @param 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.
-   * @example
-   * ```ts
-   * collection.sort((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);
-   * ```
-   */
-  sort(compareFunction = _Collection.defaultSort) {
-    const entries = [...this.entries()];
-    entries.sort((a, b) => compareFunction(a[1], b[1], a[0], b[0]));
-    super.clear();
-    for (const [key, value] of entries) {
-      super.set(key, value);
-    }
-    return this;
-  }
-  /**
-   * The intersect method returns a new structure containing items where the keys and values are present in both original structures.
-   *
-   * @param other - The other Collection to filter against
-   */
-  intersect(other) {
-    const coll = new this.constructor[Symbol.species]();
-    for (const [key, value] of other) {
-      if (this.has(key) && Object.is(value, this.get(key))) {
-        coll.set(key, value);
-      }
-    }
-    return coll;
-  }
-  /**
-   * The subtract method returns a new structure containing items where the keys and values of the original structure are not present in the other.
-   *
-   * @param other - The other Collection to filter against
-   */
-  subtract(other) {
-    const coll = new this.constructor[Symbol.species]();
-    for (const [key, value] of this) {
-      if (!other.has(key) || !Object.is(value, other.get(key))) {
-        coll.set(key, value);
-      }
-    }
-    return coll;
-  }
-  /**
-   * 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 other - The other Collection to filter against
-   */
-  difference(other) {
-    const coll = new this.constructor[Symbol.species]();
-    for (const [key, value] of other) {
-      if (!this.has(key))
-        coll.set(key, value);
-    }
-    for (const [key, value] of this) {
-      if (!other.has(key))
-        coll.set(key, value);
-    }
-    return coll;
-  }
-  /**
-   * Merges two Collections together into a new Collection.
-   *
-   * @param other - The other Collection to merge with
-   * @param whenInSelf - Function getting the result if the entry only exists in this Collection
-   * @param whenInOther - Function getting the result if the entry only exists in the other Collection
-   * @param whenInBoth - Function getting the result if the entry exists in both Collections
-   * @example
-   * ```ts
-   * // Sums up the entries in two collections.
-   * coll.merge(
-   *  other,
-   *  x => ({ keep: true, value: x }),
-   *  y => ({ keep: true, value: y }),
-   *  (x, y) => ({ keep: true, value: x + y }),
-   * );
-   * ```
-   * @example
-   * ```ts
-   * // Intersects two collections in a left-biased manner.
-   * coll.merge(
-   *  other,
-   *  x => ({ keep: false }),
-   *  y => ({ keep: false }),
-   *  (x, _) => ({ keep: true, value: x }),
-   * );
-   * ```
-   */
-  merge(other, whenInSelf, whenInOther, whenInBoth) {
-    const coll = new this.constructor[Symbol.species]();
-    const keys = /* @__PURE__ */ new Set([...this.keys(), ...other.keys()]);
-    for (const key of keys) {
-      const hasInSelf = this.has(key);
-      const hasInOther = other.has(key);
-      if (hasInSelf && hasInOther) {
-        const result = whenInBoth(this.get(key), other.get(key), key);
-        if (result.keep)
-          coll.set(key, result.value);
-      } else if (hasInSelf) {
-        const result = whenInSelf(this.get(key), key);
-        if (result.keep)
-          coll.set(key, result.value);
-      } else if (hasInOther) {
-        const result = whenInOther(other.get(key), key);
-        if (result.keep)
-          coll.set(key, result.value);
-      }
-    }
-    return coll;
-  }
-  /**
-   * The sorted method sorts the items of a collection and returns it.
-   * The sort is not necessarily stable in Node 10 or older.
-   * The default sort order is according to string Unicode code points.
-   *
-   * @param 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.
-   * @example
-   * ```ts
-   * collection.sorted((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);
-   * ```
-   */
-  sorted(compareFunction = _Collection.defaultSort) {
-    return new this.constructor[Symbol.species](this).sort((av, bv, ak, bk) => compareFunction(av, bv, ak, bk));
-  }
-  toJSON() {
-    return [...this.values()];
-  }
-  static defaultSort(firstValue, secondValue) {
-    return Number(firstValue > secondValue) || Number(firstValue === secondValue) - 1;
-  }
-  /**
-   * Creates a Collection from a list of entries.
-   *
-   * @param entries - The list of entries
-   * @param combine - Function to combine an existing entry with a new one
-   * @example
-   * ```ts
-   * Collection.combineEntries([["a", 1], ["b", 2], ["a", 2]], (x, y) => x + y);
-   * // returns Collection { "a" => 3, "b" => 2 }
-   * ```
-   */
-  static combineEntries(entries, combine) {
-    const coll = new _Collection();
-    for (const [key, value] of entries) {
-      if (coll.has(key)) {
-        coll.set(key, combine(coll.get(key), value, key));
-      } else {
-        coll.set(key, value);
-      }
-    }
-    return coll;
-  }
-};
-
-// src/index.ts
-var version = "1.5.3";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Collection,
-  version
-});
-//# sourceMappingURL=index.js.map