@sapphire/ratelimits 2.4.4 → 2.4.5-next.8eefb1e.0

package/dist/index.global.js

@@ -68,14 +68,505 @@ var SapphireRatelimits = (() => {
       return this;
     }
   };
+  __name(RateLimit, "RateLimit");
 
-  // ../time-utilities/dist/index.mjs
+  // ../utilities/dist/index.mjs
   var __defProp2 = Object.defineProperty;
-  var __defNormalProp2 = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, "__defNormalProp");
+  var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+  function arrayStrictEquals(arr1, arr2) {
+    if (arr1 === arr2)
+      return true;
+    if (arr1.length !== arr2.length)
+      return false;
+    for (let i = 0; i < arr1.length; i++) {
+      if (arr1[i] !== arr2[i] || typeof arr1[i] !== typeof arr2[i])
+        return false;
+    }
+    return true;
+  }
+  __name(arrayStrictEquals, "arrayStrictEquals");
+  __name2(arrayStrictEquals, "arrayStrictEquals");
+  function cast(value) {
+    return value;
+  }
+  __name(cast, "cast");
+  __name2(cast, "cast");
+  function chunk(array, chunkSize) {
+    if (!Array.isArray(array))
+      throw new TypeError("entries must be an array.");
+    if (!Number.isInteger(chunkSize))
+      throw new TypeError("chunkSize must be an integer.");
+    if (chunkSize < 1)
+      throw new RangeError("chunkSize must be 1 or greater.");
+    const clone = array.slice();
+    const chunks = [];
+    while (clone.length)
+      chunks.push(clone.splice(0, chunkSize));
+    return chunks;
+  }
+  __name(chunk, "chunk");
+  __name2(chunk, "chunk");
+  function classExtends(value, base) {
+    let ctor = value;
+    while (ctor !== null) {
+      if (ctor === base)
+        return true;
+      ctor = Object.getPrototypeOf(ctor);
+    }
+    return false;
+  }
+  __name(classExtends, "classExtends");
+  __name2(classExtends, "classExtends");
+  var zws = String.fromCharCode(8203);
+  function codeBlock(language, expression) {
+    if (typeof expression === "string") {
+      if (expression.length === 0)
+        return `\`\`\`${zws}\`\`\``;
+      return `\`\`\`${language}
+${expression.replace(/```/, `\`${zws}\`\``).replace(/`$/g, `\`${zws}`)}\`\`\``;
+    }
+    return `\`\`\`${language}
+${expression || zws}\`\`\``;
+  }
+  __name(codeBlock, "codeBlock");
+  __name2(codeBlock, "codeBlock");
+  function splitText(str, length, char = " ") {
+    const x = str.substring(0, length).lastIndexOf(char);
+    const pos = x === -1 ? length : x;
+    return str.substring(0, pos);
+  }
+  __name(splitText, "splitText");
+  __name2(splitText, "splitText");
+  function cutText(str, length) {
+    if (str.length < length)
+      return str;
+    const cut = splitText(str, length - 3);
+    if (cut.length < length - 3)
+      return `${cut}...`;
+    return `${cut.slice(0, length - 3)}...`;
+  }
+  __name(cutText, "cutText");
+  __name2(cutText, "cutText");
+  function debounce(func, options = {}) {
+    var _a;
+    let lastArgs;
+    let result;
+    let timerId;
+    let lastCallTime;
+    let lastInvokeTime = 0;
+    const wait = (_a = options.wait) != null ? _a : 0;
+    const maxWait = typeof options.maxWait === "number" ? Math.max(options.maxWait, wait) : null;
+    function invokeFunc(time) {
+      const args = lastArgs;
+      lastArgs = void 0;
+      lastInvokeTime = time;
+      result = func(...args);
+      return result;
+    }
+    __name(invokeFunc, "invokeFunc");
+    __name2(invokeFunc, "invokeFunc");
+    function leadingEdge(time) {
+      lastInvokeTime = time;
+      timerId = setTimeout(timerExpired, wait);
+      return result;
+    }
+    __name(leadingEdge, "leadingEdge");
+    __name2(leadingEdge, "leadingEdge");
+    function remainingWait(time) {
+      const timeSinceLastCall = time - lastCallTime;
+      const timeSinceLastInvoke = time - lastInvokeTime;
+      const result2 = wait - timeSinceLastCall;
+      return maxWait === null ? result2 : Math.min(result2, maxWait - timeSinceLastInvoke);
+    }
+    __name(remainingWait, "remainingWait");
+    __name2(remainingWait, "remainingWait");
+    function shouldInvoke(time) {
+      const timeSinceLastCall = time - lastCallTime;
+      const timeSinceLastInvoke = time - lastInvokeTime;
+      return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxWait !== null && timeSinceLastInvoke >= maxWait;
+    }
+    __name(shouldInvoke, "shouldInvoke");
+    __name2(shouldInvoke, "shouldInvoke");
+    function timerExpired() {
+      const time = Date.now();
+      if (shouldInvoke(time)) {
+        trailingEdge(time);
+        return;
+      }
+      timerId = setTimeout(timerExpired, remainingWait(time));
+    }
+    __name(timerExpired, "timerExpired");
+    __name2(timerExpired, "timerExpired");
+    function trailingEdge(time) {
+      timerId = void 0;
+      return invokeFunc(time);
+    }
+    __name(trailingEdge, "trailingEdge");
+    __name2(trailingEdge, "trailingEdge");
+    function cancel() {
+      if (timerId !== void 0) {
+        clearTimeout(timerId);
+      }
+      lastInvokeTime = 0;
+      lastArgs = void 0;
+      lastCallTime = void 0;
+      timerId = void 0;
+    }
+    __name(cancel, "cancel");
+    __name2(cancel, "cancel");
+    function flush() {
+      return timerId === void 0 ? result : trailingEdge(Date.now());
+    }
+    __name(flush, "flush");
+    __name2(flush, "flush");
+    function debounced(...args) {
+      const time = Date.now();
+      const isInvoking = shouldInvoke(time);
+      lastArgs = args;
+      lastCallTime = time;
+      if (isInvoking) {
+        if (timerId === void 0) {
+          return leadingEdge(lastCallTime);
+        }
+        if (maxWait !== null) {
+          timerId = setTimeout(timerExpired, wait);
+          return invokeFunc(lastCallTime);
+        }
+      }
+      if (timerId === void 0) {
+        timerId = setTimeout(timerExpired, wait);
+      }
+      return result;
+    }
+    __name(debounced, "debounced");
+    __name2(debounced, "debounced");
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    return debounced;
+  }
+  __name(debounce, "debounce");
+  __name2(debounce, "debounce");
+  var primitiveTypes = ["string", "bigint", "number", "boolean"];
+  function isPrimitive(input) {
+    return primitiveTypes.includes(typeof input);
+  }
+  __name(isPrimitive, "isPrimitive");
+  __name2(isPrimitive, "isPrimitive");
+  function deepClone(source) {
+    if (source === null || isPrimitive(source)) {
+      return source;
+    }
+    if (source instanceof Date) {
+      const output = new source.constructor(source);
+      return output;
+    }
+    if (Array.isArray(source)) {
+      const output = new source.constructor(source.length);
+      for (let i = 0; i < source.length; i++) {
+        output[i] = deepClone(source[i]);
+      }
+      return output;
+    }
+    if (source instanceof Map) {
+      const output = new source.constructor();
+      for (const [key, value] of source.entries()) {
+        output.set(key, deepClone(value));
+      }
+      return output;
+    }
+    if (source instanceof Set) {
+      const output = new source.constructor();
+      for (const value of source.values()) {
+        output.add(deepClone(value));
+      }
+      return output;
+    }
+    if (typeof source === "object") {
+      const output = new source.constructor();
+      for (const [key, value] of Object.entries(source)) {
+        Object.defineProperty(output, key, {
+          configurable: true,
+          enumerable: true,
+          value: deepClone(value),
+          writable: true
+        });
+      }
+      return output;
+    }
+    return source;
+  }
+  __name(deepClone, "deepClone");
+  __name2(deepClone, "deepClone");
+  function isNullOrUndefined(value) {
+    return value === void 0 || value === null;
+  }
+  __name(isNullOrUndefined, "isNullOrUndefined");
+  __name2(isNullOrUndefined, "isNullOrUndefined");
+  function filterNullAndUndefined(value) {
+    return !isNullOrUndefined(value);
+  }
+  __name(filterNullAndUndefined, "filterNullAndUndefined");
+  __name2(filterNullAndUndefined, "filterNullAndUndefined");
+  function isNullOrUndefinedOrEmpty(value) {
+    return isNullOrUndefined(value) || value.length === 0;
+  }
+  __name(isNullOrUndefinedOrEmpty, "isNullOrUndefinedOrEmpty");
+  __name2(isNullOrUndefinedOrEmpty, "isNullOrUndefinedOrEmpty");
+  function filterNullAndUndefinedAndEmpty(value) {
+    return !isNullOrUndefinedOrEmpty(value);
+  }
+  __name(filterNullAndUndefinedAndEmpty, "filterNullAndUndefinedAndEmpty");
+  __name2(filterNullAndUndefinedAndEmpty, "filterNullAndUndefinedAndEmpty");
+  function isNullOrUndefinedOrZero(value) {
+    return value === 0 || isNullOrUndefined(value);
+  }
+  __name(isNullOrUndefinedOrZero, "isNullOrUndefinedOrZero");
+  __name2(isNullOrUndefinedOrZero, "isNullOrUndefinedOrZero");
+  function filterNullAndUndefinedAndZero(value) {
+    return !isNullOrUndefinedOrZero(value);
+  }
+  __name(filterNullAndUndefinedAndZero, "filterNullAndUndefinedAndZero");
+  __name2(filterNullAndUndefinedAndZero, "filterNullAndUndefinedAndZero");
+  function hasAtLeastOneKeyInMap(map, keys) {
+    return keys.some((key) => map.has(key));
+  }
+  __name(hasAtLeastOneKeyInMap, "hasAtLeastOneKeyInMap");
+  __name2(hasAtLeastOneKeyInMap, "hasAtLeastOneKeyInMap");
+  var zws2 = String.fromCharCode(8203);
+  function inlineCodeBlock(input) {
+    return `\`${input.replace(/ /g, "\xA0").replace(/`/g, `\`${zws2}`)}\``;
+  }
+  __name(inlineCodeBlock, "inlineCodeBlock");
+  __name2(inlineCodeBlock, "inlineCodeBlock");
+  function isClass(input) {
+    return typeof input === "function" && typeof input.prototype === "object";
+  }
+  __name(isClass, "isClass");
+  __name2(isClass, "isClass");
+  function isFunction(input) {
+    return typeof input === "function";
+  }
+  __name(isFunction, "isFunction");
+  __name2(isFunction, "isFunction");
+  function isNumber(input) {
+    return typeof input === "number" && !isNaN(input) && Number.isFinite(input);
+  }
+  __name(isNumber, "isNumber");
+  __name2(isNumber, "isNumber");
+  function isObject(input, constructorType) {
+    return typeof input === "object" && input ? input.constructor === (constructorType != null ? constructorType : Object) : false;
+  }
+  __name(isObject, "isObject");
+  __name2(isObject, "isObject");
+  function hasThen(input) {
+    return Reflect.has(input, "then") && isFunction(input.then);
+  }
+  __name(hasThen, "hasThen");
+  __name2(hasThen, "hasThen");
+  function hasCatch(input) {
+    return Reflect.has(input, "catch") && isFunction(input.catch);
+  }
+  __name(hasCatch, "hasCatch");
+  __name2(hasCatch, "hasCatch");
+  function isThenable(input) {
+    if (typeof input !== "object" || input === null)
+      return false;
+    return input instanceof Promise || input !== Promise.prototype && hasThen(input) && hasCatch(input);
+  }
+  __name(isThenable, "isThenable");
+  __name2(isThenable, "isThenable");
+  function makeObject(path, value, obj = {}) {
+    if (path.includes(".")) {
+      const route = path.split(".");
+      const lastKey = route.pop();
+      let reference = obj;
+      for (const key of route) {
+        if (!reference[key])
+          reference[key] = {};
+        reference = reference[key];
+      }
+      reference[lastKey] = value;
+    } else {
+      obj[path] = value;
+    }
+    return obj;
+  }
+  __name(makeObject, "makeObject");
+  __name2(makeObject, "makeObject");
+  function mergeDefault(base, overwrites) {
+    if (!overwrites)
+      return deepClone(base);
+    for (const [baseKey, baseValue] of Object.entries(base)) {
+      const overwritesValueAtBaseKey = Reflect.get(overwrites, baseKey);
+      if (typeof overwritesValueAtBaseKey === "undefined") {
+        Reflect.set(overwrites, baseKey, deepClone(baseValue));
+      } else if (isObject(overwritesValueAtBaseKey)) {
+        Reflect.set(overwrites, baseKey, mergeDefault(baseValue != null ? baseValue : {}, overwritesValueAtBaseKey));
+      }
+    }
+    return overwrites;
+  }
+  __name(mergeDefault, "mergeDefault");
+  __name2(mergeDefault, "mergeDefault");
+  function mergeObjects(objTarget, objSource) {
+    for (const [key, value] of Object.entries(objSource)) {
+      const targetValue = Reflect.get(objTarget, key);
+      if (isObject(value)) {
+        Reflect.set(objTarget, key, isObject(targetValue) ? mergeObjects(targetValue, value) : value);
+      } else if (!isObject(targetValue)) {
+        Reflect.set(objTarget, key, value);
+      }
+    }
+    return objTarget;
+  }
+  __name(mergeObjects, "mergeObjects");
+  __name2(mergeObjects, "mergeObjects");
+  function noop() {
+  }
+  __name(noop, "noop");
+  __name2(noop, "noop");
+  function objectToTuples(original, prefix = "") {
+    const entries = [];
+    for (const [key, value] of Object.entries(original)) {
+      if (isObject(value)) {
+        entries.push(...objectToTuples(value, `${prefix}${key}.`));
+      } else {
+        entries.push([`${prefix}${key}`, value]);
+      }
+    }
+    return entries;
+  }
+  __name(objectToTuples, "objectToTuples");
+  __name2(objectToTuples, "objectToTuples");
+  function parseURL(url) {
+    try {
+      return new URL(url);
+    } catch {
+      return null;
+    }
+  }
+  __name(parseURL, "parseURL");
+  __name2(parseURL, "parseURL");
+  function partition(array, predicate) {
+    if (!Array.isArray(array))
+      throw new TypeError("entries must be an array.");
+    if (!isFunction(predicate))
+      throw new TypeError("predicate must be an function that returns a boolean value.");
+    const partitionOne = [];
+    const partitionTwo = [];
+    for (let i = 0; i < array.length; i++) {
+      if (predicate(array[i], i)) {
+        partitionOne.push(array[i]);
+      } else {
+        partitionTwo.push(array[i]);
+      }
+    }
+    return [partitionOne, partitionTwo];
+  }
+  __name(partition, "partition");
+  __name2(partition, "partition");
+  function range(min, max, step) {
+    return new Array(Math.floor((max - min) / step) + 1).fill(0).map((_val, i) => min + i * step);
+  }
+  __name(range, "range");
+  __name2(range, "range");
+  var REGEXPESC = /[-/\\^$*+?.()|[\]{}]/g;
+  function regExpEsc(str) {
+    return str.replace(REGEXPESC, "\\$&");
+  }
+  __name(regExpEsc, "regExpEsc");
+  __name2(regExpEsc, "regExpEsc");
+  function roundNumber(num, scale = 0) {
+    if (!num.toString().includes("e")) {
+      return Number(`${Math.round(Number(`${num}e+${scale}`))}e-${scale}`);
+    }
+    const arr = `${num}`.split("e");
+    let sig = "";
+    if (Number(arr[1]) + scale > 0) {
+      sig = "+";
+    }
+    return Number(`${Math.round(Number(`${Number(arr[0])}e${sig}${Number(arr[1]) + scale}`))}e-${scale}`);
+  }
+  __name(roundNumber, "roundNumber");
+  __name2(roundNumber, "roundNumber");
+  var TO_TITLE_CASE = /[A-Za-zÀ-ÖØ-öø-ÿ]\S*/g;
+  var baseVariants = {
+    textchannel: "TextChannel",
+    voicechannel: "VoiceChannel",
+    categorychannel: "CategoryChannel",
+    guildmember: "GuildMember"
+  };
+  function toTitleCase(str, options = {}) {
+    const { additionalVariants = {}, caseSensitive } = options;
+    const titleCaseVariants = {
+      ...baseVariants,
+      ...caseSensitive ? additionalVariants : Object.entries(additionalVariants).reduce((variants, [key, variant]) => ({ ...variants, [key.toLowerCase()]: variant }), {})
+    };
+    return str.replace(TO_TITLE_CASE, (txt) => {
+      var _a;
+      return (_a = titleCaseVariants[caseSensitive ? txt : txt.toLowerCase()]) != null ? _a : txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+    });
+  }
+  __name(toTitleCase, "toTitleCase");
+  __name2(toTitleCase, "toTitleCase");
+  function tryParse(value) {
+    try {
+      return JSON.parse(value);
+    } catch (err) {
+      return value;
+    }
+  }
+  __name(tryParse, "tryParse");
+  __name2(tryParse, "tryParse");
+
+  // ../time-utilities/dist/index.mjs
+  var __defProp3 = Object.defineProperty;
+  var __defNormalProp2 = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, "__defNormalProp");
+  var __name3 = /* @__PURE__ */ __name((target, value) => __defProp3(target, "name", { value, configurable: true }), "__name");
   var __publicField2 = /* @__PURE__ */ __name((obj, key, value) => {
     __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
     return value;
   }, "__publicField");
+  var days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  var months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+  var tokens = /* @__PURE__ */ new Map([
+    ["Y", 4],
+    ["Q", 1],
+    ["M", 4],
+    ["D", 4],
+    ["d", 4],
+    ["X", 1],
+    ["x", 1],
+    ["H", 2],
+    ["h", 2],
+    ["a", 1],
+    ["A", 1],
+    ["m", 2],
+    ["s", 2],
+    ["S", 3],
+    ["Z", 2],
+    ["l", 4],
+    ["L", 4],
+    ["T", 1],
+    ["t", 1]
+  ]);
+  var partRegex = /^(?:(\*)|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/;
+  var wildcardRegex = /\bh\b|\B\?\B/g;
+  var allowedNum = [
+    [0, 59],
+    [0, 23],
+    [1, 31],
+    [1, 12],
+    [0, 6]
+  ];
+  var predefined = {
+    "@annually": "0 0 1 1 *",
+    "@yearly": "0 0 1 1 *",
+    "@monthly": "0 0 1 * *",
+    "@weekly": "0 0 * * 0",
+    "@daily": "0 0 * * *",
+    "@hourly": "0 * * * *"
+  };
   var cronTokens = {
     jan: 1,
     feb: 2,
@@ -128,6 +619,90 @@ var SapphireRatelimits = (() => {
       DEFAULT: "seconds"
     }
   };
+  var DEFAULT_SEPARATORS = {
+    left: " ",
+    right: " "
+  };
+  var Cron = /* @__PURE__ */ __name(class {
+    constructor(cron) {
+      __publicField2(this, "cron");
+      __publicField2(this, "normalized");
+      __publicField2(this, "minutes");
+      __publicField2(this, "hours");
+      __publicField2(this, "days");
+      __publicField2(this, "months");
+      __publicField2(this, "dows");
+      this.cron = cron.toLowerCase();
+      this.normalized = Cron.normalize(this.cron);
+      [this.minutes, this.hours, this.days, this.months, this.dows] = Cron.parseString(this.normalized);
+    }
+    next(outset = new Date(), origin = true) {
+      if (!this.days.includes(outset.getUTCDate()) || !this.months.includes(outset.getUTCMonth() + 1) || !this.dows.includes(outset.getUTCDay())) {
+        return this.next(new Date(outset.getTime() + 864e5), false);
+      }
+      if (!origin)
+        return new Date(Date.UTC(outset.getUTCFullYear(), outset.getUTCMonth(), outset.getUTCDate(), this.hours[0], this.minutes[0]));
+      const now = new Date(outset.getTime() + 6e4);
+      for (const hour of this.hours) {
+        if (hour < now.getUTCHours())
+          continue;
+        for (const minute of this.minutes) {
+          if (hour === now.getUTCHours() && minute < now.getUTCMinutes())
+            continue;
+          return new Date(Date.UTC(outset.getUTCFullYear(), outset.getUTCMonth(), outset.getUTCDate(), hour, minute));
+        }
+      }
+      return this.next(new Date(outset.getTime() + 864e5), false);
+    }
+    static normalize(cron) {
+      if (Reflect.has(predefined, cron))
+        return Reflect.get(predefined, cron);
+      const now = new Date();
+      cron = cron.split(" ").map((val, i) => val.replace(wildcardRegex, (match) => {
+        if (match === "h")
+          return (Math.floor(Math.random() * allowedNum[i][1]) + allowedNum[i][0]).toString();
+        if (match === "?") {
+          switch (i) {
+            case 0:
+              return now.getUTCMinutes().toString();
+            case 1:
+              return now.getUTCHours().toString();
+            case 2:
+              return now.getUTCDate().toString();
+            case 3:
+              return now.getUTCMonth().toString();
+            case 4:
+              return now.getUTCDay().toString();
+          }
+        }
+        return match;
+      })).join(" ");
+      return cron.replace(tokensRegex, (match) => String(Reflect.get(cronTokens, match)));
+    }
+    static parseString(cron) {
+      const parts = cron.split(" ");
+      if (parts.length !== 5)
+        throw new Error("Invalid Cron Provided");
+      return parts.map((part, i) => Cron.parsePart(part, i));
+    }
+    static parsePart(cronPart, id) {
+      if (cronPart.includes(",")) {
+        const res = [];
+        for (const part of cronPart.split(","))
+          res.push(...Cron.parsePart(part, id));
+        return [...new Set(res)].sort((a, b) => a - b);
+      }
+      const [, wild, minStr, maxStr, step] = partRegex.exec(cronPart);
+      let [min, max] = [parseInt(minStr, 10), parseInt(maxStr, 10)];
+      if (wild)
+        [min, max] = allowedNum[id];
+      else if (!max && !step)
+        return [min];
+      [min, max] = [min, max || allowedNum[id][1]].sort((a, b) => a - b);
+      return range(min, max, parseInt(step, 10) || 1);
+    }
+  }, "Cron");
+  __name3(Cron, "Cron");
   var tokens2 = /* @__PURE__ */ new Map([
     ["nanosecond", 1 / 1e6],
     ["nanoseconds", 1 / 1e6],
@@ -168,7 +743,7 @@ var SapphireRatelimits = (() => {
     ["yrs", 1e3 * 60 * 60 * 24 * 365.25],
     ["y", 1e3 * 60 * 60 * 24 * 365.25]
   ]);
-  var _Duration = class {
+  var _Duration = /* @__PURE__ */ __name(class {
     constructor(pattern) {
       __publicField2(this, "offset");
       this.offset = _Duration.parse(pattern.toLowerCase());
@@ -192,8 +767,9 @@ var SapphireRatelimits = (() => {
       });
       return valid ? result : NaN;
     }
-  };
+  }, "_Duration");
   var Duration = _Duration;
+  __name3(Duration, "Duration");
   __publicField2(Duration, "kPatternRegex", /(-?\d*\.?\d+(?:e[-+]?\d+)?)\s*([a-zμ]*)/gi);
   __publicField2(Duration, "kCommaRegex", /,/g);
   __publicField2(Duration, "kAanRegex", /\ban?\b/gi);
@@ -206,7 +782,40 @@ var SapphireRatelimits = (() => {
     ["minute", 1e3 * 60],
     ["second", 1e3]
   ];
-  var TimerManager = class extends null {
+  var DurationFormatter = /* @__PURE__ */ __name(class {
+    constructor(units = DEFAULT_UNITS) {
+      this.units = units;
+    }
+    format(duration, precision = 7, {
+      left: leftSeparator = DEFAULT_SEPARATORS.left,
+      right: rightSeparator = DEFAULT_SEPARATORS.right
+    } = DEFAULT_SEPARATORS) {
+      const output = [];
+      const negative = duration < 0;
+      if (negative)
+        duration *= -1;
+      for (const [type, timeDuration] of kTimeDurations) {
+        const substraction = duration / timeDuration;
+        if (substraction < 1)
+          continue;
+        const floored = Math.floor(substraction);
+        duration -= floored * timeDuration;
+        output.push(addUnit(floored, this.units[type], leftSeparator));
+        if (output.length >= precision)
+          break;
+      }
+      return `${negative ? "-" : ""}${output.join(rightSeparator) || addUnit(0, this.units.second, leftSeparator)}`;
+    }
+  }, "DurationFormatter");
+  __name3(DurationFormatter, "DurationFormatter");
+  function addUnit(time, unit, separator) {
+    if (Reflect.has(unit, time))
+      return `${time}${separator}${Reflect.get(unit, time)}`;
+    return `${time}${separator}${unit.DEFAULT}`;
+  }
+  __name(addUnit, "addUnit");
+  __name3(addUnit, "addUnit");
+  var TimerManager = /* @__PURE__ */ __name(class extends null {
     static setTimeout(fn, delay, ...args) {
       const timeout = setTimeout(() => {
         this.storedTimeouts.delete(timeout);
@@ -236,9 +845,167 @@ var SapphireRatelimits = (() => {
       this.storedTimeouts.clear();
       this.storedIntervals.clear();
     }
-  };
+  }, "TimerManager");
+  __name3(TimerManager, "TimerManager");
   __publicField2(TimerManager, "storedTimeouts", /* @__PURE__ */ new Set());
   __publicField2(TimerManager, "storedIntervals", /* @__PURE__ */ new Set());
+  var tokenResolvers = /* @__PURE__ */ new Map([
+    ["Y", (time) => String(time.getFullYear()).slice(2)],
+    ["YY", (time) => String(time.getFullYear()).slice(2)],
+    ["YYY", (time) => String(time.getFullYear())],
+    ["YYYY", (time) => String(time.getFullYear())],
+    ["Q", (time) => String((time.getMonth() + 1) / 3)],
+    ["M", (time) => String(time.getMonth() + 1)],
+    ["MM", (time) => String(time.getMonth() + 1).padStart(2, "0")],
+    ["MMM", (time) => months[time.getMonth()]],
+    ["MMMM", (time) => months[time.getMonth()]],
+    ["D", (time) => String(time.getDate())],
+    ["DD", (time) => String(time.getDate()).padStart(2, "0")],
+    ["DDD", (time) => String(Math.floor((time.getTime() - new Date(time.getFullYear(), 0, 0).getTime()) / 864e5))],
+    ["DDDD", (time) => String(Math.floor((time.getTime() - new Date(time.getFullYear(), 0, 0).getTime()) / 864e5))],
+    [
+      "d",
+      (time) => {
+        const day = String(time.getDate());
+        if (day !== "11" && day.endsWith("1"))
+          return `${day}st`;
+        if (day !== "12" && day.endsWith("2"))
+          return `${day}nd`;
+        if (day !== "13" && day.endsWith("3"))
+          return `${day}rd`;
+        return `${day}th`;
+      }
+    ],
+    ["dd", (time) => days[time.getDay()].slice(0, 2)],
+    ["ddd", (time) => days[time.getDay()].slice(0, 3)],
+    ["dddd", (time) => days[time.getDay()]],
+    ["X", (time) => String(time.valueOf() / 1e3)],
+    ["x", (time) => String(time.valueOf())],
+    ["H", (time) => String(time.getHours())],
+    ["HH", (time) => String(time.getHours()).padStart(2, "0")],
+    ["h", (time) => String(time.getHours() % 12 || 12)],
+    ["hh", (time) => String(time.getHours() % 12 || 12).padStart(2, "0")],
+    ["a", (time) => time.getHours() < 12 ? "am" : "pm"],
+    ["A", (time) => time.getHours() < 12 ? "AM" : "PM"],
+    ["m", (time) => String(time.getMinutes())],
+    ["mm", (time) => String(time.getMinutes()).padStart(2, "0")],
+    ["s", (time) => String(time.getSeconds())],
+    ["ss", (time) => String(time.getSeconds()).padStart(2, "0")],
+    ["S", (time) => String(time.getMilliseconds())],
+    ["SS", (time) => String(time.getMilliseconds()).padStart(2, "0")],
+    ["SSS", (time) => String(time.getMilliseconds()).padStart(3, "0")],
+    ["T", (time) => `${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`],
+    [
+      "t",
+      (time) => `${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")}:${String(time.getSeconds()).padStart(2, "0")} ${time.getHours() < 12 ? "am" : "pm"}`
+    ],
+    ["L", (time) => `${String(time.getMonth() + 1).padStart(2, "0")}/${String(time.getDate()).padStart(2, "0")}/${String(time.getFullYear())}`],
+    ["l", (time) => `${String(time.getMonth() + 1)}/${String(time.getDate()).padStart(2, "0")}/${String(time.getFullYear())}`],
+    ["LL", (time) => `${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())}`],
+    ["ll", (time) => `${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())}`],
+    [
+      "LLL",
+      (time) => `${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+    ],
+    [
+      "lll",
+      (time) => `${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+    ],
+    [
+      "LLLL",
+      (time) => `${days[time.getDay()]}, ${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+    ],
+    [
+      "llll",
+      (time) => `${days[time.getDay()].slice(0, 3)} ${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+    ],
+    [
+      "Z",
+      (time) => {
+        const offset = time.getTimezoneOffset();
+        const unsigned = offset >= 0;
+        const absolute = Math.abs(offset);
+        return `${unsigned ? "+" : "-"}${String(Math.floor(absolute / 60)).padStart(2, "0")}:${String(absolute % 60).padStart(2, "0")}`;
+      }
+    ],
+    [
+      "ZZ",
+      (time) => {
+        const offset = time.getTimezoneOffset();
+        const unsigned = offset >= 0;
+        const absolute = Math.abs(offset);
+        return `${unsigned ? "+" : "-"}${String(Math.floor(absolute / 60)).padStart(2, "0")}:${String(absolute % 60).padStart(2, "0")}`;
+      }
+    ]
+  ]);
+  var Timestamp = /* @__PURE__ */ __name(class {
+    constructor(pattern) {
+      __publicField2(this, "pattern");
+      __publicField2(this, "template");
+      this.pattern = pattern;
+      this.template = Timestamp.parse(pattern);
+    }
+    display(time = new Date()) {
+      return Timestamp.display(this.template, time);
+    }
+    displayUTC(time) {
+      return Timestamp.display(this.template, Timestamp.utc(time));
+    }
+    edit(pattern) {
+      this.pattern = pattern;
+      this.template = Timestamp.parse(pattern);
+      return this;
+    }
+    toString() {
+      return this.display();
+    }
+    static displayArbitrary(pattern, time = new Date()) {
+      return Timestamp.display(Timestamp.parse(pattern), time);
+    }
+    static displayUTCArbitrary(pattern, time = new Date()) {
+      return Timestamp.display(Timestamp.parse(pattern), Timestamp.utc(time));
+    }
+    static utc(time = new Date()) {
+      time = Timestamp.resolveDate(time);
+      return new Date(time.valueOf() + time.getTimezoneOffset() * 6e4);
+    }
+    static display(template, time) {
+      let output = "";
+      const parsedTime = Timestamp.resolveDate(time);
+      for (const { content, type } of template)
+        output += content || tokenResolvers.get(type)(parsedTime);
+      return output;
+    }
+    static parse(pattern) {
+      const template = [];
+      for (let i = 0; i < pattern.length; i++) {
+        let current = "";
+        const currentChar = pattern[i];
+        const tokenMax = tokens.get(currentChar);
+        if (typeof tokenMax === "number") {
+          current += currentChar;
+          while (pattern[i + 1] === currentChar && current.length < tokenMax)
+            current += pattern[++i];
+          template.push({ type: current, content: null });
+        } else if (currentChar === "[") {
+          while (i + 1 < pattern.length && pattern[i + 1] !== "]")
+            current += pattern[++i];
+          i++;
+          template.push({ type: "literal", content: current || "[" });
+        } else {
+          current += currentChar;
+          while (i + 1 < pattern.length && !tokens.has(pattern[i + 1]) && pattern[i + 1] !== "[")
+            current += pattern[++i];
+          template.push({ type: "literal", content: current });
+        }
+      }
+      return template;
+    }
+    static resolveDate(time) {
+      return time instanceof Date ? time : new Date(time);
+    }
+  }, "Timestamp");
+  __name3(Timestamp, "Timestamp");
 
   // src/lib/RateLimitManager.ts
   var _RateLimitManager = class extends Map {
@@ -274,7 +1041,23 @@ var SapphireRatelimits = (() => {
     }
   };
   var RateLimitManager = _RateLimitManager;
+  __name(RateLimitManager, "RateLimitManager");
   __publicField(RateLimitManager, "sweepIntervalDuration", 3e4);
   return __toCommonJS(src_exports);
 })();
+/**
+ * Split a string by its latest space character in a range from the character 0 to the selected one.
+ * @param str The text to split.
+ * @param length The length of the desired string.
+ * @param char The character to split with
+ * @copyright 2019 Antonio Román
+ * @license Apache-2.0
+ */
+/**
+ * Split a text by its latest space character in a range from the character 0 to the selected one.
+ * @param str The text to split.
+ * @param length The length of the desired string.
+ * @copyright 2019 Antonio Román
+ * @license Apache-2.0
+ */
 //# sourceMappingURL=index.global.js.map