@design-edito/tools 0.2.39 → 0.2.40

package/agnostic/misc/data-size/index.js

@@ -1,34 +1,243 @@
-import {
-  B,
-  DataSize,
-  EB,
-  EiB,
-  GB,
-  GiB,
-  KB,
-  KiB,
-  MB,
-  MiB,
-  PB,
-  PiB,
-  TB,
-  TiB,
-  bits,
-  bytes,
-  exabytes,
-  exbibytes,
-  gibibytes,
-  gigabytes,
-  kibibytes,
-  kiloBytes,
-  mebibytes,
-  megaBytes,
-  pebibytes,
-  petabytes,
-  tebibytes,
-  terabytes
-} from "../../../chunks/chunk-G4ZB72XY.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/misc/data-size/index.ts
+var DataSize = class {
+  value;
+  unit;
+  constructor(value, unit) {
+    this.value = value;
+    if (unit === "b" || unit === "bit") {
+      this.unit = "bit";
+    } else if (unit === "B" || unit === "byte") {
+      this.unit = "byte";
+    } else if (unit === "KB" || unit === "kilobyte") {
+      this.unit = "kilobyte";
+    } else if (unit === "MB" || unit === "megabyte") {
+      this.unit = "megabyte";
+    } else if (unit === "GB" || unit === "gigabyte") {
+      this.unit = "gigabyte";
+    } else if (unit === "TB" || unit === "terabyte") {
+      this.unit = "terabyte";
+    } else if (unit === "PB" || unit === "petabyte") {
+      this.unit = "petabyte";
+    } else if (unit === "EB" || unit === "exabyte") {
+      this.unit = "exabyte";
+    } else if (unit === "KiB" || unit === "kibibyte") {
+      this.unit = "kibibyte";
+    } else if (unit === "MiB" || unit === "mebibyte") {
+      this.unit = "mebibyte";
+    } else if (unit === "GiB" || unit === "gibibyte") {
+      this.unit = "gibibyte";
+    } else if (unit === "TiB" || unit === "tebibyte") {
+      this.unit = "tebibyte";
+    } else if (unit === "PiB" || unit === "pebibyte") {
+      this.unit = "pebibyte";
+    } else if (unit === "EiB" || unit === "exbibyte") {
+      this.unit = "exbibyte";
+    } else {
+      this.unit = "byte";
+    }
+    this.toBits = this.toBits.bind(this);
+    this.toBytes = this.toBytes.bind(this);
+    this.toKilobytes = this.toKilobytes.bind(this);
+    this.toMegabytes = this.toMegabytes.bind(this);
+    this.toGigabytes = this.toGigabytes.bind(this);
+    this.toTerabytes = this.toTerabytes.bind(this);
+    this.toPetabytes = this.toPetabytes.bind(this);
+    this.toExabytes = this.toExabytes.bind(this);
+    this.toKibibytes = this.toKibibytes.bind(this);
+    this.toMebibytes = this.toMebibytes.bind(this);
+    this.toGibibytes = this.toGibibytes.bind(this);
+    this.toTebibytes = this.toTebibytes.bind(this);
+    this.toPebibytes = this.toPebibytes.bind(this);
+    this.toExbibytes = this.toExbibytes.bind(this);
+  }
+  toBits() {
+    if (this.unit === "bit") return this.value;
+    if (this.unit === "byte") return this.value * 8;
+    if (this.unit === "kilobyte") return this.value * 8 * 1e3;
+    if (this.unit === "megabyte") return this.value * 8 * 1e6;
+    if (this.unit === "gigabyte") return this.value * 8 * 1e9;
+    if (this.unit === "terabyte") return this.value * 8 * 1e12;
+    if (this.unit === "petabyte") return this.value * 8 * 1e15;
+    if (this.unit === "exabyte") return this.value * 8 * 1e18;
+    if (this.unit === "kibibyte") return this.value * 8 * 1024;
+    if (this.unit === "mebibyte") return this.value * 8 * Math.pow(1024, 2);
+    if (this.unit === "gibibyte") return this.value * 8 * Math.pow(1024, 3);
+    if (this.unit === "tebibyte") return this.value * 8 * Math.pow(1024, 4);
+    if (this.unit === "pebibyte") return this.value * 8 * Math.pow(1024, 5);
+    if (this.unit === "exbibyte") return this.value * 8 * Math.pow(1024, 6);
+    return this.value;
+  }
+  /* * * * * * * * * * * * * * * * * * 
+   * Decimal unit converters
+   * * * * * * * * * * * * * * * * * */
+  toBytes() {
+    return this.toBits() / 8;
+  }
+  toB = this.toBytes.bind(this);
+  toKilobytes() {
+    return this.toBytes() / 1e3;
+  }
+  toKB = this.toKilobytes.bind(this);
+  toMegabytes() {
+    return this.toBytes() / 1e6;
+  }
+  toMB = this.toMegabytes.bind(this);
+  toGigabytes() {
+    return this.toBytes() / 1e9;
+  }
+  toGB = this.toGigabytes.bind(this);
+  toTerabytes() {
+    return this.toBytes() / 1e12;
+  }
+  toTB = this.toTerabytes.bind(this);
+  toPetabytes() {
+    return this.toBytes() / 1e15;
+  }
+  toPB = this.toPetabytes.bind(this);
+  toExabytes() {
+    return this.toBytes() / 1e18;
+  }
+  toEB = this.toExabytes.bind(this);
+  /* * * * * * * * * * * * * * * * * * 
+   * Binary unit converters
+   * * * * * * * * * * * * * * * * * */
+  toKibibytes() {
+    return this.toBytes() / 1024;
+  }
+  toKiB = this.toKibibytes.bind(this);
+  toMebibytes() {
+    return this.toBytes() / Math.pow(1024, 2);
+  }
+  toMiB = this.toMebibytes.bind(this);
+  toGibibytes() {
+    return this.toBytes() / Math.pow(1024, 3);
+  }
+  toGiB = this.toGibibytes.bind(this);
+  toTebibytes() {
+    return this.toBytes() / Math.pow(1024, 4);
+  }
+  toTiB = this.toTebibytes.bind(this);
+  toPebibytes() {
+    return this.toBytes() / Math.pow(1024, 5);
+  }
+  toPiB = this.toPebibytes.bind(this);
+  toExbibytes() {
+    return this.toBytes() / Math.pow(1024, 6);
+  }
+  toEiB = this.toExbibytes.bind(this);
+};
+function bits(value) {
+  return new DataSize(value, "bit");
+}
+function bytes(value) {
+  return new DataSize(value, "byte");
+}
+function kilobytes(value) {
+  return new DataSize(value, "kilobyte");
+}
+function megabytes(value) {
+  return new DataSize(value, "megabyte");
+}
+function gigabytes(value) {
+  return new DataSize(value, "gigabyte");
+}
+function terabytes(value) {
+  return new DataSize(value, "terabyte");
+}
+function petabytes(value) {
+  return new DataSize(value, "petabyte");
+}
+function exabytes(value) {
+  return new DataSize(value, "exabyte");
+}
+function kibibytes(value) {
+  return new DataSize(value, "kibibyte");
+}
+function mebibytes(value) {
+  return new DataSize(value, "mebibyte");
+}
+function gibibytes(value) {
+  return new DataSize(value, "gibibyte");
+}
+function tebibytes(value) {
+  return new DataSize(value, "tebibyte");
+}
+function pebibytes(value) {
+  return new DataSize(value, "pebibyte");
+}
+function exbibytes(value) {
+  return new DataSize(value, "exbibyte");
+}
+var B = bytes;
+var KB = kilobytes;
+var MB = megabytes;
+var GB = gigabytes;
+var TB = terabytes;
+var PB = petabytes;
+var EB = exabytes;
+var KiB = kibibytes;
+var MiB = mebibytes;
+var GiB = gibibytes;
+var TiB = tebibytes;
+var PiB = pebibytes;
+var EiB = exbibytes;
+function toBits(value, unit) {
+  return new DataSize(value, unit).toBits();
+}
+function toBytes(value, unit) {
+  return new DataSize(value, unit).toBytes();
+}
+function toKilobytes(value, unit) {
+  return new DataSize(value, unit).toKilobytes();
+}
+function toMegabytes(value, unit) {
+  return new DataSize(value, unit).toMegabytes();
+}
+function toGigabytes(value, unit) {
+  return new DataSize(value, unit).toGigabytes();
+}
+function toTerabytes(value, unit) {
+  return new DataSize(value, unit).toTerabytes();
+}
+function toPetabytes(value, unit) {
+  return new DataSize(value, unit).toPetabytes();
+}
+function toExabytes(value, unit) {
+  return new DataSize(value, unit).toExabytes();
+}
+function toKibibytes(value, unit) {
+  return new DataSize(value, unit).toKibibytes();
+}
+function toMebibytes(value, unit) {
+  return new DataSize(value, unit).toMebibytes();
+}
+function toGibibytes(value, unit) {
+  return new DataSize(value, unit).toGibibytes();
+}
+function toTebibytes(value, unit) {
+  return new DataSize(value, unit).toTebibytes();
+}
+function toPebibytes(value, unit) {
+  return new DataSize(value, unit).toPebibytes();
+}
+function toExbibytes(value, unit) {
+  return new DataSize(value, unit).toExbibytes();
+}
+var toB = toBytes;
+var toKB = toKilobytes;
+var toMB = toMegabytes;
+var toGB = toGigabytes;
+var toTB = toTerabytes;
+var toPB = toPetabytes;
+var toEB = toExabytes;
+var toKiB = toKibibytes;
+var toMiB = toMebibytes;
+var toGiB = toGibibytes;
+var toTiB = toTebibytes;
+var toPiB = toPebibytes;
+var toEiB = toExbibytes;
 export {
   B,
   DataSize,
@@ -51,11 +260,38 @@ export {
   gibibytes,
   gigabytes,
   kibibytes,
-  kiloBytes,
+  kilobytes,
   mebibytes,
-  megaBytes,
+  megabytes,
   pebibytes,
   petabytes,
   tebibytes,
-  terabytes
+  terabytes,
+  toB,
+  toBits,
+  toBytes,
+  toEB,
+  toEiB,
+  toExabytes,
+  toExbibytes,
+  toGB,
+  toGiB,
+  toGibibytes,
+  toGigabytes,
+  toKB,
+  toKiB,
+  toKibibytes,
+  toKilobytes,
+  toMB,
+  toMebibytes,
+  toMegabytes,
+  toMiB,
+  toPB,
+  toPebibytes,
+  toPetabytes,
+  toPiB,
+  toTB,
+  toTebibytes,
+  toTerabytes,
+  toTiB
 };

package/agnostic/misc/data-size/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Binary data units (base 1024).
+ *
+ * - `'kibibyte'` : 1024 bytes
+ * - `'mebibyte'` : 1024² bytes
+ * - `'gibibyte'` : 1024³ bytes
+ * - `'tebibyte'` : 1024⁴ bytes
+ * - `'pebibyte'` : 1024⁵ bytes
+ * - `'exbibyte'` : 1024⁶ bytes
+ */
+export type BinaryUnit = 'kibibyte' | 'mebibyte' | 'gibibyte' | 'tebibyte' | 'pebibyte' | 'exbibyte';
+/**
+ * Short forms of binary data units.
+ *
+ * - `'KiB'`, `'MiB'`, `'GiB'`, `'TiB'`, `'PiB'`, `'EiB'`
+ */
+export type BinaryUnitShort = 'KiB' | 'MiB' | 'GiB' | 'TiB' | 'PiB' | 'EiB';
+/**
+ * Decimal data units (base 1000).
+ *
+ * - `'bit'`, `'byte'`, `'kilobyte'`, `'megabyte'`, `'gigabyte'`, `'terabyte'`, `'petabyte'`, `'exabyte'`
+ */
+export type DecimalUnit = 'bit' | 'byte' | 'kilobyte' | 'megabyte' | 'gigabyte' | 'terabyte' | 'petabyte' | 'exabyte';
+/**
+ * Short forms of decimal data units.
+ *
+ * - `'b'`, `'B'`, `'KB'`, `'MB'`, `'GB'`, `'TB'`, `'PB'`, `'EB'`
+ */
+export type DecimalUnitShort = 'b' | 'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB';
+/**
+ * Any supported data unit (binary or decimal).
+ */
+export type Unit = BinaryUnit | DecimalUnit;
+/**
+ * Any supported short-form data unit (binary or decimal).
+ */
+export type UnitShort = BinaryUnitShort | DecimalUnitShort;

package/agnostic/misc/elo/index.d.ts

@@ -1,31 +1,29 @@
-export declare namespace Elo {
-    const K_FACTOR = 32;
-    /**
-     * Calcule la probabilité de gain de A en fonction des scores Elo de A et B.
-     * @param eloA Le score Elo du joueur A.
-     * @param eloB Le score Elo du joueur B.
-     * @returns La probabilité que le joueur A gagne contre le joueur B.
-     */
-    function getWinProbability(eloA: number, eloB: number): number;
-    /**
-     * Calcule les nouveaux classements Elo pour les scénarios de victoire de A, de B et de match nul.
-     * @param eloA Le score Elo actuel du joueur A.
-     * @param eloB Le score Elo actuel du joueur B.
-     * @param kFactor Facteur K pour les calculs Elo (facultatif, valeur par défaut = 32).
-     * @returns Un objet contenant les nouveaux classements Elo pour chaque scénario de résultat.
-     */
-    function getOutcome(eloA: number, eloB: number, kFactor?: number): {
-        aWins: {
-            eloA: number;
-            eloB: number;
-        };
-        bWins: {
-            eloA: number;
-            eloB: number;
-        };
-        null: {
-            eloA: number;
-            eloB: number;
-        };
+export declare const K_FACTOR = 32;
+/**
+ * Calcule la probabilité de gain de A en fonction des scores Elo de A et B.
+ * @param eloA Le score Elo du joueur A.
+ * @param eloB Le score Elo du joueur B.
+ * @returns La probabilité que le joueur A gagne contre le joueur B.
+ */
+export declare function getWinProbability(eloA: number, eloB: number): number;
+/**
+ * Calcule les nouveaux classements Elo pour les scénarios de victoire de A, de B et de match nul.
+ * @param eloA Le score Elo actuel du joueur A.
+ * @param eloB Le score Elo actuel du joueur B.
+ * @param kFactor Facteur K pour les calculs Elo (facultatif, valeur par défaut = 32).
+ * @returns Un objet contenant les nouveaux classements Elo pour chaque scénario de résultat.
+ */
+export declare function getOutcome(eloA: number, eloB: number, kFactor?: number): {
+    aWins: {
+        eloA: number;
+        eloB: number;
     };
-}
+    bWins: {
+        eloA: number;
+        eloB: number;
+    };
+    null: {
+        eloA: number;
+        eloB: number;
+    };
+};

package/agnostic/misc/elo/index.js

@@ -1,34 +1,31 @@
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 
 // src/agnostic/misc/elo/index.ts
-var Elo;
-((Elo2) => {
-  Elo2.K_FACTOR = 32;
-  function getWinProbability(eloA, eloB) {
-    const exponent = (eloB - eloA) / 400;
-    return 1 / (1 + Math.pow(10, exponent));
-  }
-  Elo2.getWinProbability = getWinProbability;
-  function getOutcome(eloA, eloB, kFactor = Elo2.K_FACTOR) {
-    const probA = getWinProbability(eloA, eloB);
-    const probB = 1 - probA;
-    return {
-      aWins: {
-        eloA: Math.round(eloA + kFactor * (1 - probA)),
-        eloB: Math.round(eloB + kFactor * (0 - probB))
-      },
-      bWins: {
-        eloA: Math.round(eloA + kFactor * (0 - probA)),
-        eloB: Math.round(eloB + kFactor * (1 - probB))
-      },
-      null: {
-        eloA: Math.round(eloA + kFactor * (0.5 - probA)),
-        eloB: Math.round(eloB + kFactor * (0.5 - probB))
-      }
-    };
-  }
-  Elo2.getOutcome = getOutcome;
-})(Elo || (Elo = {}));
+var K_FACTOR = 32;
+function getWinProbability(eloA, eloB) {
+  const exponent = (eloB - eloA) / 400;
+  return 1 / (1 + Math.pow(10, exponent));
+}
+function getOutcome(eloA, eloB, kFactor = K_FACTOR) {
+  const probA = getWinProbability(eloA, eloB);
+  const probB = 1 - probA;
+  return {
+    aWins: {
+      eloA: Math.round(eloA + kFactor * (1 - probA)),
+      eloB: Math.round(eloB + kFactor * (0 - probB))
+    },
+    bWins: {
+      eloA: Math.round(eloA + kFactor * (0 - probA)),
+      eloB: Math.round(eloB + kFactor * (1 - probB))
+    },
+    null: {
+      eloA: Math.round(eloA + kFactor * (0.5 - probA)),
+      eloB: Math.round(eloB + kFactor * (0.5 - probB))
+    }
+  };
+}
 export {
-  Elo
+  K_FACTOR,
+  getOutcome,
+  getWinProbability
 };

package/agnostic/misc/is-constructor-function/index.d.ts

@@ -1,2 +1,13 @@
+/**
+ * Represents a class or constructor function.
+ *
+ * @template T - The type of object constructed by the function.
+ */
 export type ConstructorFunction<T extends any = any> = new (...args: any[]) => T;
+/**
+ * Checks whether a given value is a constructor function (i.e., a class or function with a prototype).
+ *
+ * @param {unknown} input - The value to check.
+ * @returns {input is ConstructorFunction} `true` if the input is a constructor function, otherwise `false`.
+ */
 export declare function isConstructorFunction(input: unknown): input is ConstructorFunction;

package/agnostic/misc/is-constructor-function/index.js

@@ -1,7 +1,7 @@
 import {
   isConstructorFunction
 } from "../../../chunks/chunk-RCO57B6F.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   isConstructorFunction
 };

package/agnostic/misc/is-nullish/index.d.ts

@@ -1,4 +1,26 @@
+/**
+ * Array of values considered "nullish".
+ *
+ * Contains `null` and `undefined`.
+ */
 export declare const nullishValues: (null | undefined)[];
+/**
+ * Represents a nullish value (`null` or `undefined`).
+ */
 export type Nullish = null | undefined;
+/**
+ * Checks whether a value is nullish (`null` or `undefined`).
+ *
+ * @template T
+ * @param {T | Nullish} val - The value to check.
+ * @returns {val is Nullish} `true` if the value is nullish, otherwise `false`.
+ */
 export declare function isNullish<T>(val: T | Nullish): val is Nullish;
+/**
+ * Checks whether a value is not nullish (`null` or `undefined`).
+ *
+ * @template T
+ * @param {T} val - The value to check.
+ * @returns {val is Exclude<T, Nullish>} `true` if the value is not nullish, otherwise `false`.
+ */
 export declare function isNotNullish<T>(val: T): val is Exclude<T, Nullish>;

package/agnostic/misc/is-nullish/index.js

@@ -3,7 +3,7 @@ import {
   isNullish,
   nullishValues
 } from "../../../chunks/chunk-HC6ZOHCS.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../chunks/chunk-XCBH6NLF.js";
 export {
   isNotNullish,
   isNullish,

package/agnostic/misc/logs/logger/index.js

@@ -1,7 +1,112 @@
-import {
-  Logger
-} from "../../../../chunks/chunk-RASMASS4.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
+
+// src/agnostic/misc/logs/logger/index.ts
+var logsTimeOrigin = /* @__PURE__ */ new Date();
+var Log = class {
+  type;
+  data;
+  time;
+  stack;
+  constructor(type, data) {
+    this.type = type;
+    this.data = data;
+    this.time = /* @__PURE__ */ new Date();
+    this.stack = new Error().stack ?? "";
+  }
+  get displayTime() {
+    return this.time.toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      weekday: "short",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    }) + `:${this.time.getMilliseconds()}`;
+  }
+  get elapsedTimeMs() {
+    return (this.time.getTime() - logsTimeOrigin.getTime()) / 1e3;
+  }
+  get displayStack() {
+    return this.stack.split("\n").map((line) => line.trim()).slice(4).join("\n");
+  }
+};
+var Logger = class {
+  _private_threads = /* @__PURE__ */ new Map();
+  constructor() {
+    this.dir = this.dir.bind(this);
+    this.error = this.error.bind(this);
+    this.group = this.group.bind(this);
+    this.groupEnd = this.groupEnd.bind(this);
+    this.log = this.log.bind(this);
+    this.table = this.table.bind(this);
+    this.warn = this.warn.bind(this);
+    this.setLog = this.setLog.bind(this);
+    this.print = this.print.bind(this);
+    this.printThreads = this.printThreads.bind(this);
+  }
+  // assert         (thread: string = '', ...args: ConsoleMethodsParams['assert'])         { this.setLog(thread, 'assert', args) }
+  // count          (thread: string = '', ...args: ConsoleMethodsParams['count'])          { this.setLog(thread, 'count', args) }
+  // countReset     (thread: string = '', ...args: ConsoleMethodsParams['countReset'])     { this.setLog(thread, 'countReset', args) }
+  // debug          (thread: string = '', ...args: ConsoleMethodsParams['debug'])          { this.setLog(thread, 'debug', args) }
+  dir(thread = "", ...args) {
+    this.setLog(thread, "dir", args);
+  }
+  // dirxml         (thread: string = '', ...args: ConsoleMethodsParams['dirxml'])         { this.setLog(thread, 'dirxml', args) }
+  error(thread = "", ...args) {
+    this.setLog(thread, "error", args);
+  }
+  group(thread = "", ...args) {
+    this.setLog(thread, "group", args);
+  }
+  // groupCollapsed (thread: string = '', ...args: ConsoleMethodsParams['groupCollapsed']) { this.setLog(thread, 'groupCollapsed', args) }
+  groupEnd(thread = "", ...args) {
+    this.setLog(thread, "groupEnd", args);
+  }
+  // info           (thread: string = '', ...args: ConsoleMethodsParams['info'])           { this.setLog(thread, 'info', args) }
+  log(thread = "", ...args) {
+    this.setLog(thread, "log", args);
+  }
+  table(thread = "", ...args) {
+    this.setLog(thread, "table", args);
+  }
+  // time           (thread: string = '', ...args: ConsoleMethodsParams['time'])           { this.setLog(thread, 'time', args) }
+  // timeEnd        (thread: string = '', ...args: ConsoleMethodsParams['timeEnd'])        { this.setLog(thread, 'timeEnd', args) }
+  // trace          (thread: string = '', ...args: ConsoleMethodsParams['trace'])          { this.setLog(thread, 'trace', args) }
+  warn(thread = "", ...args) {
+    this.setLog(thread, "warn", args);
+  }
+  setLog(threadName, type, data) {
+    const log = new Log(type, data);
+    const thread = this._private_threads.get(threadName) ?? [];
+    this._private_threads.set(threadName, [...thread, log]);
+    return this;
+  }
+  print(threadFilter, withStack) {
+    const allLogs = Array.from(this._private_threads.entries()).map(([threadName, logs]) => logs.map((log) => ({ threadName, log }))).flat().sort((eltA, eltB) => eltA.log.time.getTime() - eltB.log.time.getTime()).filter(({ threadName }) => {
+      if (threadFilter === void 0) return true;
+      return threadName === threadFilter;
+    });
+    allLogs.forEach(({ threadName, log }) => {
+      console.log(`%c${threadName}`, "font-weight: 800; color: white; background: black; padding: 4px;", `+${log.elapsedTimeMs}s \u2013`, log.displayTime);
+      if (withStack === true) console.log(`%c${log.displayStack}`, "color: grey; font-size: inherit;");
+      console[log.type](...log.data);
+      console.log("");
+    });
+  }
+  printThreads(withStack) {
+    Array.from(this._private_threads.entries()).forEach(([threadName, logs]) => {
+      console.group(`%c${threadName}`, "font-weight: 800; color: white; background: black; padding: 4px;");
+      logs.forEach((log) => {
+        console.log(`+${log.elapsedTimeMs}s \u2013`, log.displayTime);
+        if (withStack === true) console.log(`%c${log.displayStack}`, "color: grey; font-size: inherit;");
+        console[log.type](...log.data);
+        console.log("");
+      });
+      console.groupEnd();
+    });
+  }
+};
 export {
   Logger
 };

package/agnostic/misc/logs/make-text-block/index.js

@@ -1,7 +1,7 @@
 import {
   makeTextBlock
 } from "../../../../chunks/chunk-H4PP6AHP.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   makeTextBlock
 };

package/agnostic/misc/logs/styles/index.js

@@ -2,7 +2,7 @@ import {
   styles
 } from "../../../../chunks/chunk-L3OCRR3V.js";
 import "../../../../chunks/chunk-H4PP6AHP.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+import "../../../../chunks/chunk-XCBH6NLF.js";
 export {
   styles
 };