cognova 0.2.2 → 0.2.4

package/.output/server/node_modules/discord.js/src/util/UserFlagsBitField.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const { UserFlags } = require('discord-api-types/v10');
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with a {@link User#flags} bitfield.
+ * @extends {BitField}
+ */
+class UserFlagsBitField extends BitField {
+  /**
+   * Numeric user flags.
+   * @type {UserFlags}
+   * @memberof UserFlagsBitField
+   */
+  static Flags = UserFlags;
+}
+
+/**
+ * @name UserFlagsBitField
+ * @kind constructor
+ * @memberof UserFlagsBitField
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Bitfield of the packed bits
+ * @type {number}
+ * @name UserFlagsBitField#bitfield
+ */
+
+module.exports = UserFlagsBitField;

package/.output/server/node_modules/discord.js/src/util/Util.js

@@ -0,0 +1,558 @@
+'use strict';
+
+const { parse } = require('node:path');
+const process = require('node:process');
+const { Collection } = require('@discordjs/collection');
+const { ChannelType, RouteBases, Routes } = require('discord-api-types/v10');
+const { fetch } = require('undici');
+const Colors = require('./Colors');
+const { DiscordjsError, DiscordjsRangeError, DiscordjsTypeError, ErrorCodes } = require('../errors');
+const isObject = d => typeof d === 'object' && d !== null;
+
+let deprecationEmittedForUserFetchFlags = false;
+let deprecationEmittedForRemoveThreadMember = false;
+
+/**
+ * Flatten an object. Any properties that are collections will get converted to an array of keys.
+ * @param {Object} obj The object to flatten.
+ * @param {...Object<string, boolean|string>} [props] Specific properties to include/exclude.
+ * @returns {Object}
+ */
+function flatten(obj, ...props) {
+  if (!isObject(obj)) return obj;
+
+  const objProps = Object.keys(obj)
+    .filter(key => !key.startsWith('_'))
+    .map(key => ({ [key]: true }));
+
+  props = objProps.length ? Object.assign(...objProps, ...props) : Object.assign({}, ...props);
+
+  const out = {};
+
+  for (let [prop, newProp] of Object.entries(props)) {
+    if (!newProp) continue;
+    newProp = newProp === true ? prop : newProp;
+
+    const element = obj[prop];
+    const elemIsObj = isObject(element);
+    const valueOf = elemIsObj && typeof element.valueOf === 'function' ? element.valueOf() : null;
+    const hasToJSON = elemIsObj && typeof element.toJSON === 'function';
+
+    // If it's a Collection, make the array of keys
+    if (element instanceof Collection) out[newProp] = Array.from(element.keys());
+    // If the valueOf is a Collection, use its array of keys
+    else if (valueOf instanceof Collection) out[newProp] = Array.from(valueOf.keys());
+    // If it's an array, call toJSON function on each element if present, otherwise flatten each element
+    else if (Array.isArray(element)) out[newProp] = element.map(elm => elm.toJSON?.() ?? flatten(elm));
+    // If it's an object with a primitive `valueOf`, use that value
+    else if (typeof valueOf !== 'object') out[newProp] = valueOf;
+    // If it's an object with a toJSON function, use the return value of it
+    else if (hasToJSON) out[newProp] = element.toJSON();
+    // If element is an object, use the flattened version of it
+    else if (typeof element === 'object') out[newProp] = flatten(element);
+    // If it's a primitive
+    else if (!elemIsObj) out[newProp] = element;
+  }
+
+  return out;
+}
+
+/**
+ * @typedef {Object} FetchRecommendedShardCountOptions
+ * @property {number} [guildsPerShard=1000] Number of guilds assigned per shard
+ * @property {number} [multipleOf=1] The multiple the shard count should round up to. (16 for large bot sharding)
+ */
+
+/**
+ * Gets the recommended shard count from Discord.
+ * @param {string} token Discord auth token
+ * @param {FetchRecommendedShardCountOptions} [options] Options for fetching the recommended shard count
+ * @returns {Promise<number>} The recommended number of shards
+ */
+async function fetchRecommendedShardCount(token, { guildsPerShard = 1_000, multipleOf = 1 } = {}) {
+  if (!token) throw new DiscordjsError(ErrorCodes.TokenMissing);
+  const response = await fetch(RouteBases.api + Routes.gatewayBot(), {
+    method: 'GET',
+    headers: { Authorization: `Bot ${token.replace(/^Bot\s*/i, '')}` },
+  });
+  if (!response.ok) {
+    if (response.status === 401) throw new DiscordjsError(ErrorCodes.TokenInvalid);
+    throw response;
+  }
+  const { shards } = await response.json();
+  return Math.ceil((shards * (1_000 / guildsPerShard)) / multipleOf) * multipleOf;
+}
+
+/**
+ * A partial emoji object.
+ * @typedef {Object} PartialEmoji
+ * @property {boolean} animated Whether the emoji is animated
+ * @property {Snowflake|undefined} id The id of the emoji
+ * @property {string} name The name of the emoji
+ */
+
+/**
+ * Parses emoji info out of a string. The string must be one of:
+ * * A UTF-8 emoji (no id)
+ * * A URL-encoded UTF-8 emoji (no id)
+ * * A Discord custom emoji (`<:name:id>` or `<a:name:id>`)
+ * @param {string} text Emoji string to parse
+ * @returns {?PartialEmoji}
+ */
+function parseEmoji(text) {
+  if (text.includes('%')) text = decodeURIComponent(text);
+  if (!text.includes(':')) return { animated: false, name: text, id: undefined };
+  const match = text.match(/<?(?:(a):)?(\w{2,32}):(\d{17,19})?>?/);
+  return match && { animated: Boolean(match[1]), name: match[2], id: match[3] };
+}
+
+/**
+ * A partial emoji object with only an id.
+ * @typedef {Object} PartialEmojiOnlyId
+ * @property {Snowflake} id The id of the emoji
+ */
+
+/**
+ * Resolves a partial emoji object from an {@link EmojiIdentifierResolvable}, without checking a Client.
+ * @param {Emoji|EmojiIdentifierResolvable} emoji Emoji identifier to resolve
+ * @returns {?(PartialEmoji|PartialEmojiOnlyId)} Supplying a snowflake yields `PartialEmojiOnlyId`.
+ * @private
+ */
+function resolvePartialEmoji(emoji) {
+  if (!emoji) return null;
+  if (typeof emoji === 'string') return /^\d{17,19}$/.test(emoji) ? { id: emoji } : parseEmoji(emoji);
+  const { id, name, animated } = emoji;
+  if (!id && !name) return null;
+  return { id, name, animated: Boolean(animated) };
+}
+
+/**
+ * Options used to make an error object.
+ * @typedef {Object} MakeErrorOptions
+ * @property {string} name Error type
+ * @property {string} message Message for the error
+ * @property {string} stack Stack for the error
+ * @private
+ */
+
+/**
+ * Makes an Error from a plain info object.
+ * @param {MakeErrorOptions} obj Error info
+ * @returns {Error}
+ * @private
+ */
+function makeError(obj) {
+  const err = new Error(obj.message);
+  err.name = obj.name;
+  err.stack = obj.stack;
+  return err;
+}
+
+/**
+ * Makes a plain error info object from an Error.
+ * @param {Error} err Error to get info from
+ * @returns {MakeErrorOptions}
+ * @private
+ */
+function makePlainError(err) {
+  return {
+    name: err.name,
+    message: err.message,
+    stack: err.stack,
+  };
+}
+
+const TextSortableGroupTypes = [
+  ChannelType.GuildText,
+  ChannelType.GuildAnnouncement,
+  ChannelType.GuildForum,
+  ChannelType.GuildMedia,
+];
+
+const VoiceSortableGroupTypes = [ChannelType.GuildVoice, ChannelType.GuildStageVoice];
+const CategorySortableGroupTypes = [ChannelType.GuildCategory];
+
+/**
+ * Gets an array of the channel types that can be moved in the channel group. For example, a GuildText channel would
+ * return an array containing the types that can be ordered within the text channels (always at the top), and a voice
+ * channel would return an array containing the types that can be ordered within the voice channels (always at the
+ * bottom).
+ * @param {ChannelType} type The type of the channel
+ * @returns {ChannelType[]}
+ * @private
+ */
+function getSortableGroupTypes(type) {
+  switch (type) {
+    case ChannelType.GuildText:
+    case ChannelType.GuildAnnouncement:
+    case ChannelType.GuildForum:
+    case ChannelType.GuildMedia:
+      return TextSortableGroupTypes;
+    case ChannelType.GuildVoice:
+    case ChannelType.GuildStageVoice:
+      return VoiceSortableGroupTypes;
+    case ChannelType.GuildCategory:
+      return CategorySortableGroupTypes;
+    default:
+      return [type];
+  }
+}
+
+/**
+ * Moves an element in an array *in place*.
+ * @param {Array<*>} array Array to modify
+ * @param {*} element Element to move
+ * @param {number} newIndex Index or offset to move the element to
+ * @param {boolean} [offset=false] Move the element by an offset amount rather than to a set index
+ * @returns {number}
+ * @private
+ */
+function moveElementInArray(array, element, newIndex, offset = false) {
+  const index = array.indexOf(element);
+  newIndex = (offset ? index : 0) + newIndex;
+  if (newIndex > -1 && newIndex < array.length) {
+    const removedElement = array.splice(index, 1)[0];
+    array.splice(newIndex, 0, removedElement);
+  }
+  return array.indexOf(element);
+}
+
+/**
+ * Verifies the provided data is a string, otherwise throws provided error.
+ * @param {string} data The string resolvable to resolve
+ * @param {Function} [error] The Error constructor to instantiate. Defaults to Error
+ * @param {string} [errorMessage] The error message to throw with. Defaults to "Expected string, got <data> instead."
+ * @param {boolean} [allowEmpty=true] Whether an empty string should be allowed
+ * @returns {string}
+ */
+function verifyString(
+  data,
+  error = Error,
+  errorMessage = `Expected a string, got ${data} instead.`,
+  allowEmpty = true,
+) {
+  if (typeof data !== 'string') throw new error(errorMessage);
+  if (!allowEmpty && data.length === 0) throw new error(errorMessage);
+  return data;
+}
+
+/**
+ * Can be a number, hex string, an RGB array like:
+ * ```js
+ * [255, 0, 255] // purple
+ * ```
+ * or one of the following strings:
+ * - `Default`
+ * - `White`
+ * - `Aqua`
+ * - `Green`
+ * - `Blue`
+ * - `Yellow`
+ * - `Purple`
+ * - `LuminousVividPink`
+ * - `Fuchsia`
+ * - `Gold`
+ * - `Orange`
+ * - `Red`
+ * - `Grey`
+ * - `Navy`
+ * - `DarkAqua`
+ * - `DarkGreen`
+ * - `DarkBlue`
+ * - `DarkPurple`
+ * - `DarkVividPink`
+ * - `DarkGold`
+ * - `DarkOrange`
+ * - `DarkRed`
+ * - `DarkGrey`
+ * - `DarkerGrey`
+ * - `LightGrey`
+ * - `DarkNavy`
+ * - `Blurple`
+ * - `Greyple`
+ * - `DarkButNotBlack`
+ * - `NotQuiteBlack`
+ * - `Random`
+ * @typedef {string|number|number[]} ColorResolvable
+ */
+
+/**
+ * Resolves a ColorResolvable into a color number.
+ * @param {ColorResolvable} color Color to resolve
+ * @returns {number} A color
+ */
+function resolveColor(color) {
+  let resolvedColor;
+
+  if (typeof color === 'string') {
+    if (color === 'Random') return Math.floor(Math.random() * (0xffffff + 1));
+    if (color === 'Default') return 0;
+    if (/^#?[\da-f]{6}$/i.test(color)) return parseInt(color.replace('#', ''), 16);
+    resolvedColor = Colors[color];
+  } else if (Array.isArray(color)) {
+    resolvedColor = (color[0] << 16) + (color[1] << 8) + color[2];
+  } else {
+    resolvedColor = color;
+  }
+
+  if (!Number.isInteger(resolvedColor)) {
+    throw new DiscordjsTypeError(ErrorCodes.ColorConvert, color);
+  }
+
+  if (resolvedColor < 0 || resolvedColor > 0xffffff) {
+    throw new DiscordjsRangeError(ErrorCodes.ColorRange);
+  }
+
+  return resolvedColor;
+}
+
+/**
+ * Sorts by Discord's position and id.
+ * @param {Collection} collection Collection of objects to sort
+ * @returns {Collection}
+ */
+function discordSort(collection) {
+  const isGuildChannel = collection.first() instanceof GuildChannel;
+  return collection.sorted(
+    isGuildChannel
+      ? (a, b) => a.rawPosition - b.rawPosition || Number(BigInt(a.id) - BigInt(b.id))
+      : (a, b) => a.rawPosition - b.rawPosition || Number(BigInt(b.id) - BigInt(a.id)),
+  );
+}
+
+/**
+ * Sets the position of a Channel or Role.
+ * @param {BaseChannel|Role} item Object to set the position of
+ * @param {number} position New position for the object
+ * @param {boolean} relative Whether `position` is relative to its current position
+ * @param {Collection<string, BaseChannel|Role>} sorted A collection of the objects sorted properly
+ * @param {Client} client The client to use to patch the data
+ * @param {string} route Route to call PATCH on
+ * @param {string} [reason] Reason for the change
+ * @returns {Promise<BaseChannel[]|Role[]>} Updated item list, with `id` and `position` properties
+ * @private
+ */
+async function setPosition(item, position, relative, sorted, client, route, reason) {
+  let updatedItems = [...sorted.values()];
+  moveElementInArray(updatedItems, item, position, relative);
+  updatedItems = updatedItems.map((r, i) => ({ id: r.id, position: i }));
+  await client.rest.patch(route, { body: updatedItems, reason });
+  return updatedItems;
+}
+
+/**
+ * Alternative to Node's `path.basename`, removing query string after the extension if it exists.
+ * @param {string} path Path to get the basename of
+ * @param {string} [ext] File extension to remove
+ * @returns {string} Basename of the path
+ * @private
+ */
+function basename(path, ext) {
+  const res = parse(path);
+  return ext && res.ext.startsWith(ext) ? res.name : res.base.split('?')[0];
+}
+
+/**
+ * The content to have all mentions replaced by the equivalent text.
+ * @param {string} str The string to be converted
+ * @param {TextBasedChannels} channel The channel the string was sent in
+ * @returns {string}
+ */
+function cleanContent(str, channel) {
+  return str.replaceAll(
+    /* eslint-disable max-len */
+    /<(?:(?<type>@[!&]?|#)|(?:\/(?<commandName>[-_\p{L}\p{N}\p{sc=Deva}\p{sc=Thai} ]+):)|(?:a?:(?<emojiName>[\w]+):))(?<id>\d{17,19})>/gu,
+    (match, type, commandName, emojiName, id) => {
+      if (commandName) return `/${commandName}`;
+
+      if (emojiName) return `:${emojiName}:`;
+
+      switch (type) {
+        case '@':
+        case '@!': {
+          const member = channel.guild?.members.cache.get(id);
+          if (member) {
+            return `@${member.displayName}`;
+          }
+
+          const user = channel.client.users.cache.get(id);
+          return user ? `@${user.displayName}` : match;
+        }
+        case '@&': {
+          if (channel.type === ChannelType.DM) return match;
+          const role = channel.guild.roles.cache.get(id);
+          return role ? `@${role.name}` : match;
+        }
+        case '#': {
+          const mentionedChannel = channel.client.channels.cache.get(id);
+          return mentionedChannel ? `#${mentionedChannel.name}` : match;
+        }
+        default: {
+          return match;
+        }
+      }
+    },
+  );
+}
+
+/**
+ * The content to put in a code block with all code block fences replaced by the equivalent backticks.
+ * @param {string} text The string to be converted
+ * @returns {string}
+ */
+function cleanCodeBlockContent(text) {
+  return text.replaceAll('```', '`\u200b``');
+}
+
+/**
+ * Parses a webhook URL for the id and token.
+ * @param {string} url The URL to parse
+ * @returns {?WebhookClientDataIdWithToken} `null` if the URL is invalid, otherwise the id and the token
+ */
+function parseWebhookURL(url) {
+  const matches = url.match(
+    /https?:\/\/(?:ptb\.|canary\.)?discord\.com\/api(?:\/v\d{1,2})?\/webhooks\/(\d{17,19})\/([\w-]{68})/i,
+  );
+
+  if (!matches || matches.length <= 2) return null;
+
+  const [, id, token] = matches;
+  return {
+    id,
+    token,
+  };
+}
+
+/**
+ * Supportive data for interaction resolved data.
+ * @typedef {Object} SupportingInteractionResolvedData
+ * @property {Client} client The client
+ * @property {Guild} [guild] A guild
+ * @property {GuildTextBasedChannel} [channel] A channel
+ * @private
+ */
+
+/**
+ * Transforms the resolved data received from the API.
+ * @param {SupportingInteractionResolvedData} supportingData Data to support the transformation
+ * @param {APIInteractionDataResolved} [data] The received resolved objects
+ * @returns {CommandInteractionResolvedData}
+ * @private
+ */
+function transformResolved(
+  { client, guild, channel },
+  { members, users, channels, roles, messages, attachments } = {},
+) {
+  const result = {};
+
+  if (members) {
+    result.members = new Collection();
+    for (const [id, member] of Object.entries(members)) {
+      const user = users[id];
+      result.members.set(id, guild?.members._add({ user, ...member }) ?? member);
+    }
+  }
+
+  if (users) {
+    result.users = new Collection();
+    for (const user of Object.values(users)) {
+      result.users.set(user.id, client.users._add(user));
+    }
+  }
+
+  if (roles) {
+    result.roles = new Collection();
+    for (const role of Object.values(roles)) {
+      result.roles.set(role.id, guild?.roles._add(role) ?? role);
+    }
+  }
+
+  if (channels) {
+    result.channels = new Collection();
+    for (const apiChannel of Object.values(channels)) {
+      result.channels.set(apiChannel.id, client.channels._add(apiChannel, guild) ?? apiChannel);
+    }
+  }
+
+  if (messages) {
+    result.messages = new Collection();
+    for (const message of Object.values(messages)) {
+      result.messages.set(message.id, channel?.messages?._add(message) ?? message);
+    }
+  }
+
+  if (attachments) {
+    result.attachments = new Collection();
+    for (const attachment of Object.values(attachments)) {
+      const patched = new Attachment(attachment);
+      result.attachments.set(attachment.id, patched);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Resolves a SKU id from a SKU resolvable.
+ * @param {SKUResolvable} resolvable The SKU resolvable to resolve
+ * @returns {?Snowflake} The resolved SKU id, or `null` if the resolvable was invalid
+ */
+function resolveSKUId(resolvable) {
+  if (typeof resolvable === 'string') return resolvable;
+  if (resolvable instanceof SKU) return resolvable.id;
+  return null;
+}
+
+/**
+ * Deprecation function for fetching user flags.
+ * @param {string} name Name of the class
+ * @private
+ */
+function emitDeprecationWarningForUserFetchFlags(name) {
+  if (deprecationEmittedForUserFetchFlags) return;
+  process.emitWarning(`${name}#fetchFlags() is deprecated. Use ${name}#fetch() instead.`);
+  deprecationEmittedForUserFetchFlags = true;
+}
+
+/**
+ * Deprecation function for the reason parameter of removing thread members.
+ * @param {string} name Name of the class
+ * @private
+ */
+function emitDeprecationWarningForRemoveThreadMember(name) {
+  if (deprecationEmittedForRemoveThreadMember) return;
+
+  process.emitWarning(
+    `The reason parameter of ${name}#remove() is deprecated as Discord does not parse them. It will be removed in the next major version.`,
+  );
+
+  deprecationEmittedForRemoveThreadMember = true;
+}
+
+module.exports = {
+  flatten,
+  fetchRecommendedShardCount,
+  parseEmoji,
+  resolvePartialEmoji,
+  makeError,
+  makePlainError,
+  getSortableGroupTypes,
+  moveElementInArray,
+  verifyString,
+  resolveColor,
+  discordSort,
+  setPosition,
+  basename,
+  cleanContent,
+  cleanCodeBlockContent,
+  parseWebhookURL,
+  transformResolved,
+  resolveSKUId,
+  emitDeprecationWarningForUserFetchFlags,
+  emitDeprecationWarningForRemoveThreadMember,
+};
+
+// Fixes Circular
+const Attachment = require('../structures/Attachment');
+const GuildChannel = require('../structures/GuildChannel');
+const { SKU } = require('../structures/SKU.js');

package/.output/server/node_modules/discord.js/src/util/WebSocketShardEvents.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/**
+ * @typedef {Object} WebSocketShardEvents
+ * @property {string} Close close
+ * @property {string} Destroyed destroyed
+ * @property {string} InvalidSession invalidSession
+ * @property {string} Ready ready
+ * @property {string} Resumed resumed
+ * @property {string} AllReady allReady
+ */
+
+// JSDoc for IntelliSense purposes
+/**
+ * @type {WebSocketShardEvents}
+ * @ignore
+ */
+module.exports = {
+  Close: 'close',
+  Destroyed: 'destroyed',
+  InvalidSession: 'invalidSession',
+  Ready: 'ready',
+  Resumed: 'resumed',
+  AllReady: 'allReady',
+};

package/.output/server/node_modules/fast-deep-equal/es6/index.js

@@ -0,0 +1,72 @@
+'use strict';
+
+// do not edit .js files directly - edit src/index.jst
+
+
+  var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';
+
+
+module.exports = function equal(a, b) {
+  if (a === b) return true;
+
+  if (a && b && typeof a == 'object' && typeof b == 'object') {
+    if (a.constructor !== b.constructor) return false;
+
+    var length, i, keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length) return false;
+      for (i = length; i-- !== 0;)
+        if (!equal(a[i], b[i])) return false;
+      return true;
+    }
+
+
+    if ((a instanceof Map) && (b instanceof Map)) {
+      if (a.size !== b.size) return false;
+      for (i of a.entries())
+        if (!b.has(i[0])) return false;
+      for (i of a.entries())
+        if (!equal(i[1], b.get(i[0]))) return false;
+      return true;
+    }
+
+    if ((a instanceof Set) && (b instanceof Set)) {
+      if (a.size !== b.size) return false;
+      for (i of a.entries())
+        if (!b.has(i[0])) return false;
+      return true;
+    }
+
+    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+      length = a.length;
+      if (length != b.length) return false;
+      for (i = length; i-- !== 0;)
+        if (a[i] !== b[i]) return false;
+      return true;
+    }
+
+
+    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length) return false;
+
+    for (i = length; i-- !== 0;)
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+
+    for (i = length; i-- !== 0;) {
+      var key = keys[i];
+
+      if (!equal(a[key], b[key])) return false;
+    }
+
+    return true;
+  }
+
+  // true if both NaN, false otherwise
+  return a!==a && b!==b;
+};