@prozilla-os/shared 1.2.1 → 1.3.0

package/dist/main.js

@@ -1,11 +1,7 @@
-var g = Object.defineProperty;
-var m = (t) => {
-  throw TypeError(t);
-};
-var M = (t, n, e) => n in t ? g(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
-var d = (t, n, e) => M(t, typeof n != "symbol" ? n + "" : n, e), y = (t, n, e) => n.has(t) || m("Cannot " + e);
-var i = (t, n, e) => (y(t, n, "read from private field"), e ? e.call(t) : n.get(t)), x = (t, n, e) => n.has(t) ? m("Cannot add the same private member more than once") : n instanceof WeakSet ? n.add(t) : n.set(t, e);
-const A = {
+const h = {
+  /**
+   * Foreground colors.
+   */
   fg: {
     black: "\x1B[30m",
     red: "\x1B[31m",
@@ -16,24 +12,49 @@ const A = {
     cyan: "\x1B[36m",
     white: "\x1B[37m"
   },
-  bg: {},
+  /**
+   * Background colors.
+   */
+  bg: {
+    black: "\x1B[40m",
+    red: "\x1B[41m",
+    green: "\x1B[42m",
+    yellow: "\x1B[43m",
+    blue: "\x1B[44m",
+    magenta: "\x1B[45m",
+    cyan: "\x1B[46m",
+    white: "\x1B[47m"
+  },
+  /**
+   * Screen buffer and clearing controls.
+   */
+  screen: {
+    enterAltBuffer: "\x1B[?1049h",
+    exitAltBuffer: "\x1B[?1049l",
+    clear: "\x1B[2J",
+    home: "\x1B[H"
+  },
+  /**
+   * Decorations.
+   */
   decoration: {
     dim: "\x1B[2m",
-    bold: "\x1B[1m"
+    bold: "\x1B[1m",
+    underline: "\x1B[4m"
   },
   reset: "\x1B[0m"
 };
-function E(t, n) {
-  const e = n.indexOf(t);
-  e !== -1 && n.splice(e, 1);
+function x(r, t) {
+  const e = t.indexOf(r);
+  e !== -1 && t.splice(e, 1);
 }
-function O(t) {
-  return t[Math.floor(Math.random() * t.length)];
+function A(r) {
+  return r[Math.floor(Math.random() * r.length)];
 }
-function T(t) {
-  return t.filter((n, e) => t.indexOf(n) === e);
+function F(r) {
+  return r.filter((t, e) => r.indexOf(t) === e);
 }
-const p = {
+const m = {
   s: 1e3,
   m: 1e3 * 60,
   h: 1e3 * 60 * 60,
@@ -43,97 +64,675 @@ const p = {
   y: 1e3 * 60 * 60 * 24 * 365,
   c: 1e3 * 60 * 60 * 24 * 365 * 100
 };
-function b(t, n = 3, e) {
-  const s = [], a = (o, f) => {
+function y(r, t = 3, e = !1) {
+  const i = [], s = (o, l) => {
     if (!e)
       return o.join(", ");
-    let u = "", h = "";
-    return f ? h = "ago" : u = "in", [u, o.join(", "), h].join(" ").trim();
+    let f = "", g = "";
+    return l ? g = "ago" : f = "in", [f, o.join(", "), g].join(" ").trim();
   };
-  let c = !1;
-  if (t < 0 && (t = -t, c = !0), Math.abs(t) < p.s)
-    return a(["less than a second"], c);
-  const l = [], B = {
-    s: "seconds",
-    m: "minutes",
-    h: "hours",
-    d: "days",
-    n: "months",
-    y: "years"
+  let u = !1;
+  if (r < 0 && (r = -r, u = !0), Math.abs(r) < m.s)
+    return s(["less than a second"], u);
+  const c = [], d = {
+    s: "second",
+    m: "minute",
+    h: "hour",
+    d: "day",
+    n: "month",
+    y: "year"
   };
-  for (const [o, f] of Object.entries(p).reverse()) {
+  for (const [o, l] of Object.entries(m).reverse()) {
     if (o === "w" || o === "c")
       continue;
-    const u = Math.floor(t / f);
-    t -= u * f, u > 0 && l.push({ amount: u, label: B[o] });
+    const f = Math.floor(r / l);
+    r -= f * l, f > 0 && c.push({ amount: f, label: f != 1 ? d[o] + "s" : d[o] });
+  }
+  for (let o = 0; o < t; o++)
+    if (o < c.length) {
+      const l = c[o];
+      i.push(`${l.amount} ${l.label}`);
+    }
+  return i.length === 0 ? s(["less than a second"], u) : s(i, u);
+}
+function C(r, t = 3, e = !1) {
+  const i = r.valueOf() - Date.now();
+  return y(i, t, e);
+}
+class R {
+  #t = {};
+  /**
+   * Starts listening to an event.
+   * @param event - The event to listen to.
+   * @param listener - The function to call when the event is emitted.
+   * @returns The listener.
+   */
+  on(t, e) {
+    return this.#t[t] === void 0 ? this.#t[t] = [e] : this.#t[t].push(e), e;
+  }
+  /**
+   * Registers an event listener that is automatically removed when called.
+   * @param event - The event to listen to.
+   * @param listener - The function to call once the event is emitted.
+   * @returns The wrapped listener.
+   */
+  once(t, e) {
+    const i = this.on(t, (...s) => {
+      this.off(t, i), e(...s);
+    });
+    return i;
   }
-  for (let o = 0; o < n; o++) {
-    const f = l[o];
-    f && s.push(`${f.amount} ${f.label}`);
+  /**
+   * Starts listening to an event.
+   * @param event - The event to listen to.
+   * @param listener - The function to call when the event is emitted.
+   * @returns The wrapped listener. 
+   */
+  onAsync(t, e, i) {
+    return this.on(t, (...s) => {
+      e(...s).catch((u) => {
+        i ? i(u) : console.error(u);
+      });
+    });
   }
-  return s.length === 0 ? a(["less than a second"], c) : a(s, c);
+  /**
+   * Removes an event listener.
+   * @param event - The event to remove the listener from.
+   * @param listener - The listener to remove.
+   */
+  off(t, e) {
+    this.#t[t] !== void 0 && x(e, this.#t[t]);
+  }
+  /**
+   * Emits an event to all its listeners.
+   * @param event - The event to emit.
+   * @param args - The arguments to pass to the listeners.
+   */
+  emit(t, ...e) {
+    if (this.#t[t] !== void 0)
+      for (const i of this.#t[t])
+        i(...e);
+  }
+}
+function q(r, t, e) {
+  return r < t ? t : r > e ? e : r;
+}
+function O(r, t) {
+  return Math.random() * (t - r) + r;
+}
+function W(r, t) {
+  const e = Math.pow(10, t ?? 0);
+  return Math.round(r * e) / e;
+}
+function p(r) {
+  return typeof r == "number" ? !0 : r.trim() === "" ? !1 : Number.isInteger(Number(r));
+}
+function b(r) {
+  return typeof r == "number" ? !0 : r.trim() === "" ? !1 : !isNaN(Number(r));
+}
+function X(r, t = 0) {
+  return r !== void 0 && p(r) ? Number(r) : t;
+}
+function Y(r, t = 0) {
+  return r !== void 0 && b(r) ? parseFloat(r) : t;
 }
-function j(t, n = 3, e) {
-  const s = t.valueOf() - Date.now();
-  return b(s, n, e);
+function Z(r) {
+  return r.trim().toLowerCase() === "true";
 }
-var r;
-class w {
-  constructor() {
-    x(this, r, {});
+function H(r) {
+  if (!r.length) return "";
+  let t = r[0];
+  for (let e = 1; e < r.length; e++)
+    for (; r[e].indexOf(t) !== 0; )
+      if (t = t.substring(0, t.length - 1), t === "") return "";
+  return t;
+}
+class n {
+  /**
+   * Makes text black using {@link ANSI.fg.black}.
+   */
+  static black(t) {
+    return n.#t(t, h.fg.black);
   }
   /**
-   * Add event listener for an event
+   * Makes text red using {@link ANSI.fg.red}.
    */
-  on(n, e) {
-    return i(this, r)[n] || (i(this, r)[n] = []), i(this, r)[n].push(e), e;
+  static red(t) {
+    return n.#t(t, h.fg.red);
   }
   /**
-   * Remove event listener for an event
+   * Makes text green using {@link ANSI.fg.green}.
    */
-  off(n, e) {
-    i(this, r)[n] && (i(this, r)[n] = i(this, r)[n].filter(
-      (s) => s !== e
-    ));
+  static green(t) {
+    return n.#t(t, h.fg.green);
   }
   /**
-   * Dispatch event
+   * Makes text yellow using {@link ANSI.fg.yellow}.
    */
-  emit(n, e) {
-    i(this, r)[n] && i(this, r)[n].forEach((s) => {
-      s(e);
-    });
+  static yellow(t) {
+    return n.#t(t, h.fg.yellow);
+  }
+  /**
+   * Makes text blue using {@link ANSI.fg.blue}.
+   */
+  static blue(t) {
+    return n.#t(t, h.fg.blue);
+  }
+  /**
+   * Makes text magenta using {@link ANSI.fg.magenta}.
+   */
+  static magenta(t) {
+    return n.#t(t, h.fg.magenta);
+  }
+  /**
+   * Makes text cyan using {@link ANSI.fg.cyan}.
+   */
+  static cyan(t) {
+    return n.#t(t, h.fg.cyan);
+  }
+  /**
+   * Makes text white using {@link ANSI.fg.white}.
+   */
+  static white(t) {
+    return n.#t(t, h.fg.white);
+  }
+  /**
+   * Makes text bold using {@link ANSI.decoration.bold}.
+   */
+  static bold(t) {
+    return n.#t(t, h.decoration.bold);
+  }
+  /**
+   * Makes text dim using {@link ANSI.decoration.dim}.
+   */
+  static dim(t) {
+    return n.#t(t, h.decoration.dim);
+  }
+  static #t(t, e) {
+    return t = t.replaceAll(h.reset, h.reset + e), e + t + h.reset;
+  }
+  /**
+   * Removes all ANSI escape sequences.
+   */
+  static strip(t) {
+    return t.replace(/\u001b\[[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+  }
+  /**
+   * Removes ANSI escape sequences for colors and background colors (SGR).
+   */
+  static stripColors(t) {
+    return t.replace(/\u001b\[[0-9;]*m/g, "");
+  }
+}
+var w = /* @__PURE__ */ ((r) => (r[r.Debug = 0] = "Debug", r[r.Info = 1] = "Info", r[r.Success = 2] = "Success", r[r.Warning = 3] = "Warning", r[r.Error = 4] = "Error", r))(w || {});
+class J {
+  /**
+   * The minimum log level or an array of log levels to enable.
+   * 
+   * `undefined` enables all log levels. An array enables all log levels in that array. A single level enables that log level and the ones above.
+   * @default LogLevel.Debug
+   */
+  level;
+  /**
+   * The current level of indentation.
+   * @default 0
+   */
+  indent = 0;
+  /**
+   * The string to use for indentation.
+   * @default "\t"
+   */
+  indentString;
+  /**
+   * The function to use when highlighting text.
+   * @default Ansi.cyan
+   * @see {@link Ansi.cyan}
+   */
+  highlight = n.cyan;
+  /**
+   * The function to use when emphasizing text.
+   * @default Ansi.bold
+   * @see {@link Ansi.bold}
+   */
+  emphasize = n.bold;
+  /**
+  	 * The prefixes to prepend to logs.
+  	 * @default {
+  	[LogLevel.Info]: Ansi.cyan("[info]"),
+  	[LogLevel.Success]: Ansi.green("[success]"),
+  	[LogLevel.Warning]: Ansi.yellow("[warning]"),
+  	[LogLevel.Error]: Ansi.red("[error]"),
+  }
+  	 */
+  prefix = {};
+  #t = 0;
+  #e = 0;
+  constructor(t) {
+    this.reset(), t !== void 0 && (Array.isArray(t) || typeof t == "number" ? this.level = t : (t.level !== void 0 && (this.level = t.level), t.prefix && (typeof t.prefix == "string" ? this.prefix.global = t.prefix : this.prefix = {
+      ...this.prefix,
+      ...t.prefix
+    })));
+  }
+  // ===== Modifying state =====
+  /**
+   * Resets all properties to their default values.
+   */
+  reset() {
+    return this.level = 0, this.indent = 0, this.indentString = "	", this.highlight = n.cyan, this.emphasize = n.bold, this.prefix = {
+      1: n.cyan("[info]"),
+      2: n.green("[success]"),
+      3: n.yellow("[warning]"),
+      4: n.red("[error]")
+    }, this.#t = 0, this.#e = 0, this;
+  }
+  indented(t, e = 1, i) {
+    return i !== void 0 && !this.isLevelEnabled(i) ? this : (this.indent + e < 0 && (e = -this.indent), this.tab(e), typeof t == "function" ? t() : Array.isArray(t) ? this.lines(t, i) : this.log(t, i), this.shiftTab(e), this);
+  }
+  /**
+   * Increases the level of indentation.
+   * @param amount - The amount to increase the level of indentation with.
+   */
+  tab(t = 1) {
+    return this.indent += t, this.indent < 0 && (this.indent = 0), this;
+  }
+  /**
+   * Decreases the level of indentation.
+   * @param amount - The amount to decrease the level of indentation with.
+   */
+  shiftTab(t = 1) {
+    return this.indent -= t, this.indent < 0 && (this.indent = 0), this;
+  }
+  setPrefix(t, e) {
+    return typeof t == "string" ? this.prefix = {
+      global: t
+    } : typeof t == "object" ? this.prefix = t : this.prefix[t] = e, this;
+  }
+  // ===== Logging status messages =====
+  /**
+   * Logs an info message about a URL being fetched.
+   * @param url - The URL being fetched.
+   */
+  fetching(t) {
+    return this.pending(`Fetching: ${this.highlight(t)}`);
   }
+  /**
+   * Logs an info message that implies a pending state.
+   * @param message - The status message.
+   */
+  pending(t) {
+    return this.info(n.yellow(t));
+  }
+  /**
+   * Logs an error message.
+   * @param message - The error message or reason.
+   * @param details - The details of the error message.
+   */
+  error(t, ...e) {
+    return this.#t++, this.isLevelEnabled(
+      4
+      /* Error */
+    ) ? (typeof t == "string" ? this.statusMessage(
+      n.red(t),
+      e,
+      4
+      /* Error */
+    ) : console.error(t, ...e), this) : this;
+  }
+  /**
+   * Logs a warning message.
+   * @param message - The warning message.
+   * @param details - The details of the warning message.
+   */
+  warn(t, ...e) {
+    return this.#e++, this.statusMessage(
+      n.yellow(t),
+      e,
+      3
+      /* Warning */
+    );
+  }
+  /**
+   * Logs a success message.
+   * @param message - The success message.
+   * @param details - The details of the success message.
+   */
+  success(t, ...e) {
+    return this.statusMessage(
+      n.green(t),
+      e,
+      2
+      /* Success */
+    );
+  }
+  /**
+   * Logs an info message.
+   * @param message - The info message.
+   * @param details - The details of the info message.
+   */
+  info(t, ...e) {
+    return this.statusMessage(
+      t,
+      e,
+      1
+      /* Info */
+    );
+  }
+  /**
+   * Logs a status message.
+   * @param message - The status message.
+   * @param details - The details of the status message.
+   * @param level - The log level.
+   */
+  statusMessage(t, e, i) {
+    let s = t;
+    if (e.length) {
+      const u = this.indentString ? this.indentString.repeat(this.indent + 1) : "	";
+      s += `
+` + e.map((c) => u + String(c)).join(`
+`);
+    }
+    return this.text(s, i);
+  }
+  /**
+   * Logs the amount of errors and warnings that have been logged since the previous call to this function or the creation of this logger.
+   */
+  summary() {
+    const t = `${this.#t} error${this.#t != 1 ? "s" : ""}`, e = `${this.#e} warning${this.#e != 1 ? "s" : ""}`;
+    let i = `Found ${t} and ${e}`;
+    return this.#t > 0 ? i = n.red(i) : this.#e > 0 ? i = n.yellow(i) : i = n.green(i), this.text(i), this.#t = 0, this.#e = 0, this;
+  }
+  // ===== Logging text =====
+  /**
+   * Logs a labeled parameter.
+   * 
+   * The value is emphasized using {@link emphasize}.
+   * @param label - The label of the parameter.
+   * @param value - The value of the parameter.
+   * @param level - The log level.
+   */
+  parameter(t, e, i) {
+    return this.text(`${t}: ${this.emphasize(String(e))}`, i);
+  }
+  /**
+   * Logs properties as a list of key-value pairs.
+   * @param properties - The properties to log.
+   * @param level - The log level.
+   * @see {@link value()}
+   */
+  properties(t, e) {
+    for (const [i, s] of Object.entries(t))
+      this.value(`- ${i}`, s, e);
+    return this;
+  }
+  /**
+   * Logs a labeled value.
+   * 
+   * The value is highlighted using {@link highlight}.
+   * @param label - The label of the value.
+   * @param value - The value.
+   * @param level - The log level.
+   */
+  value(t, e, i) {
+    return this.text(`${t}: ${this.highlight(String(e))}`, i);
+  }
+  /**
+   * Logs emphasized text.
+   * @param text - The text to log.
+   * @param level - The log level.
+   */
+  emphasized(t, e) {
+    return this.text(this.emphasize(t), e);
+  }
+  /**
+   * Logs highlighted text.
+   * @param text - The text to log.
+   * @param level - The log level.
+   */
+  highlighted(t, e) {
+    return this.text(this.highlight(t), e);
+  }
+  /**
+   * Logs each item on a new line.
+   * @param lines - The items to log.
+   * @param level - The log level.
+   */
+  lines(t, e) {
+    return t.map(String).forEach((i) => this.text(i, e)), this;
+  }
+  /**
+   * Logs a message.
+   * @param message - The message to log.
+   * @param level - The log level.
+   */
+  log(t, e) {
+    return this.text(String(t), e);
+  }
+  /**
+   * Logs text using this logger's format.
+   * @param text - The text to log.
+   * @param level - The log level.
+   */
+  text(t, e = 0) {
+    if (!this.isLevelEnabled(e))
+      return this;
+    const i = this.format(this.applyPrefix(t, e));
+    switch (e) {
+      case 1:
+        console.info(i);
+        break;
+      case 3:
+        console.warn(i);
+        break;
+      case 4:
+        console.error(i);
+        break;
+      default:
+        console.log(i);
+        break;
+    }
+    return this;
+  }
+  /**
+   * Logs an newline character.
+   */
+  newLine() {
+    return console.log(`
+`), this;
+  }
+  /**
+   * Checks if the given log level is enabled.
+   * @param level - The log level to check.
+   */
+  isLevelEnabled(t) {
+    return this.level === void 0 ? !0 : Array.isArray(this.level) ? this.level.includes(t) : this.level <= t;
+  }
+  // ===== Formatting strings =====
+  /**
+   * Formats text using this logger's formatting properties.
+   * @param text - The text to format.
+   */
+  format(t) {
+    return this.indentString ? this.applyPrefix(this.indentString.repeat(this.indent) + t) : this.applyPrefix(t);
+  }
+  /**
+   * Prepends a prefix to text.
+   * @param text - The text to apply the prefix to.
+   * @param level - The log level.
+   */
+  applyPrefix(t, e) {
+    const i = e ? this.prefix[e] : this.prefix.global;
+    return i ? `${i} ${t}` : t;
+  }
+}
+function $(r) {
+  return `# ${r}`;
+}
+function B(r) {
+  return `## ${r}`;
 }
-r = new WeakMap(), d(w, "EVENT_NAMES", {});
-function R(t, n, e) {
-  return t < n ? n : t > e ? e : t;
+function S(r) {
+  return `### ${r}`;
 }
-function D(t, n) {
-  return Math.random() * (n - t) + t;
+function M(r) {
+  return `#### ${r}`;
 }
-function F(t, n) {
-  const e = Math.pow(10, n || 0);
-  return Math.round(t * e) / e;
+function v(r) {
+  return `##### ${r}`;
 }
-function S(t) {
-  return typeof t == "number" || parseInt(t) || parseInt(t) === 0;
+function k(r) {
+  return `###### ${r}`;
 }
-function C(t) {
-  return t.trim().toLowerCase() === "true";
+function E(r) {
+  return `**${r}**`;
+}
+function z(r) {
+  return `*${r}*`;
+}
+function D(r) {
+  return `\`${r}\``;
+}
+function I(r) {
+  return `\`\`\`${r}\`\`\``;
+}
+function N(r) {
+  return `~~${r}~~`;
+}
+function P(r, t) {
+  return `[${r}](${t})`;
+}
+function T(r) {
+  return `> ${r}`;
+}
+function j() {
+  return "---";
+}
+const G = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  bold: E,
+  code: D,
+  codeBlock: I,
+  heading1: $,
+  heading2: B,
+  heading3: S,
+  heading4: M,
+  heading5: v,
+  heading6: k,
+  horizontalRule: j,
+  italic: z,
+  link: P,
+  quote: T,
+  strikethrough: N
+}, Symbol.toStringTag, { value: "Module" }));
+class a {
+  x;
+  y;
+  constructor(t, e) {
+    this.x = t, this.y = e ?? t;
+  }
+  static get ZERO() {
+    return new a(0, 0);
+  }
+  get clone() {
+    return new a(this.x, this.y);
+  }
+  get magnitude() {
+    return this.getDistance(this);
+  }
+  setX(t) {
+    return this.x = t, this;
+  }
+  setY(t) {
+    return this.y = t, this;
+  }
+  set(t, e) {
+    return this.x = t, this.y = e, this;
+  }
+  round() {
+    return this.x = Math.round(this.x), this.y = Math.round(this.y), this;
+  }
+  normalize() {
+    const t = this.magnitude;
+    return this.scale(t === 0 ? 0 : 1 / t);
+  }
+  scale(t) {
+    return this.multiply(t);
+  }
+  getDistanceSquared(t, e) {
+    const i = a.parseVector(t, e), s = this.x - i.x, u = this.y - i.y;
+    return s * s + u * u;
+  }
+  getDistance(t, e) {
+    const i = a.parseVector(t, e);
+    return Math.sqrt(this.getDistanceSquared(i.x, i.y));
+  }
+  add(t, e) {
+    const i = a.parseVector(t, e);
+    return this.x += i.x, this.y += i.y, this;
+  }
+  subtract(t, e) {
+    const i = a.parseVector(t, e);
+    return this.x -= i.x, this.y -= i.y, this;
+  }
+  multiply(t, e) {
+    const i = a.parseVector(t, e);
+    return this.x *= i.x, this.y *= i.y, this;
+  }
+  divide(t, e) {
+    const i = a.parseVector(t, e);
+    return this.x /= i.x, this.y /= i.y, this;
+  }
+  lerp(t, e) {
+    return this.x += (t.x - this.x) * e, this.y += (t.y - this.y) * e, this;
+  }
+  static sum(t, e) {
+    return t.clone.add(e);
+  }
+  static difference(t, e) {
+    return t.clone.subtract(e);
+  }
+  static product(t, e) {
+    return t.clone.multiply(e);
+  }
+  static division(t, e) {
+    return t.clone.divide(e);
+  }
+  static scale(t, e) {
+    return t.clone.scale(e);
+  }
+  static normalize(t) {
+    return t.clone.normalize();
+  }
+  static lerp(t, e, i) {
+    return t.clone.lerp(e, i);
+  }
+  static from({ x: t, y: e }) {
+    return new a(t, e);
+  }
+  static parseVector(t, e) {
+    return t instanceof a ? (e = t.y, t = t.x) : e === void 0 && (e = t), { x: t, y: e };
+  }
 }
 export {
-  A as ANSI,
-  w as EventEmitter,
-  R as clamp,
-  j as formatRelativeTime,
-  b as formatTime,
-  S as isValidInteger,
-  C as parseBool,
-  O as randomFromArray,
-  D as randomRange,
-  T as removeDuplicatesFromArray,
-  E as removeFromArray,
-  F as round
+  h as ANSI,
+  n as Ansi,
+  R as EventEmitter,
+  w as LogLevel,
+  J as Logger,
+  G as Markdown,
+  a as Vector2,
+  q as clamp,
+  C as formatRelativeTime,
+  y as formatTime,
+  H as getLongestCommonPrefix,
+  p as isValidInteger,
+  b as isValidNumber,
+  Z as parseBool,
+  Y as parseOptionalFloat,
+  X as parseOptionalInteger,
+  A as randomFromArray,
+  O as randomRange,
+  F as removeDuplicatesFromArray,
+  x as removeFromArray,
+  W as round
 };
 //# sourceMappingURL=main.js.map