@kikiutils/shared 18.3.0 → 20.0.0

package/README.md

@@ -16,7 +16,6 @@ A lightweight, modular TypeScript utility library for Node.js and browser projec
 - 🔁 General helpers — normalize single-or-array values with `extractFirstValue`.
 - 🧬 Binary helpers — convert `Blob`, `File`, `ArrayBuffer`, `Uint8Array`, and `Buffer` to Node `Buffer`.
 - 🔒 Hashing helpers — SHA-3 helpers for universal usage and Node `crypto` MD5/SHA-3 helpers.
-- 📜 Logging helpers — preconfigured Consola and Pino logger instances with env-based levels.
 - 📅 Date helpers — format dates and compute common ranges such as today, this week, and last month.
 - 🔢 Number and math helpers — compact number display, precise percentages, and fixed-decimal arithmetic.
 - 🔤 String/random helpers — random strings and randomized-length value generation.
@@ -52,7 +51,6 @@ You can also use `npm`, `yarn`, or `bun`.
 Import individual modules to keep dependency usage explicit:
 
 ```typescript
-import { logger } from '@kikiutils/shared/consola';
 import { extractFirstValue } from '@kikiutils/shared/general';
 
 const value = extractFirstValue([
@@ -69,7 +67,6 @@ logger.info(value); // 0
 | --- | --- | --- | --- |
 | `buffer` | Node/browser-compatible inputs, Node output | `toBuffer` | Convert `Blob`, `File`, `ArrayBuffer`, `Uint8Array`, or `Buffer` to Node `Buffer`. |
 | `clipboard` | Browser | `copyTextToClipboard`, `copyBlobToClipboard` | Safe result wrappers around the modern Clipboard API. |
-| `consola` | Node/browser | `consolaLogger`, `logger` | Shared Consola instance with env-based log level. |
 | `crypto-hash` | Node | `cryptoMd5`, `cryptoSha3*`, `*ToBuffer` | Node `crypto` MD5/SHA-3 helpers with text or raw-buffer output. |
 | `datetime` | Node/browser | `formatDate`, `getDateRangeFromDate`, `getMidnightDateFromToday` | Date formatting and common date-range calculations via `date-fns`. |
 | `element-plus` | Vue/browser | `createElFormItemRuleWithDefaults` | Create Element Plus form rules with default `required`, `trigger`, and `type`. |
@@ -80,8 +77,6 @@ logger.info(value); // 0
 | `hash` | Any | `sha3224`, `sha3256`, `sha3384`, `sha3512` | SHA-3 helpers backed by `@noble/hashes`; returns hex strings. |
 | `math` | Any | `toPercentageString` | Precise percentage strings using `decimal.js`. |
 | `number` | Any | `toCompactNumberString` | Compact display strings using `millify`. |
-| `object` | Any | `stringifyObjectDeterministically` | Stable flattened object serialization for signatures/cache keys. |
-| `pino` | Node | `pinoLogger`, `logger` | Shared Pino logger with pretty output and env-based level. |
 | `random` | Any | `generateWithNestedRandomLength` | Generate values with a two-step randomized length. |
 | `string` | Any | `randomString` | Random strings from preset character sets. |
 | `time` | Any | `abortableDelay` | Promise delay that resolves early on abort. |
@@ -158,8 +153,6 @@ Most modules are tiny wrappers around platform APIs or optional peers. If your p
 | `element-plus` | `async-validator`, `element-plus` |
 | `classes/precision-number`, `math` | `decimal.js` |
 | `number` | `millify` |
-| `consola` | `consola` |
-| `pino` | `pino`, `pino-pretty` |
 | `storages/lru/keyed-store` | `lru-cache` |
 | `storages/redis/msgpack` | `msgpackr` |
 | `vue` | `vue`, `vue-router` |

package/dist/buffer.d.ts

@@ -1,6 +1,5 @@
 import { BinaryInput } from "./types/index.js";
 import { Buffer } from "node:buffer";
-//#region src/buffer.d.ts
 /**
  * Converts binary input to a Node.js `Buffer`.
  *
@@ -31,5 +30,4 @@ import { Buffer } from "node:buffer";
  * ```
  */
 export declare function toBuffer(input: BinaryInput): Promise<Buffer<ArrayBufferLike>>;
-//#endregion
 //# sourceMappingURL=buffer.d.ts.map

package/dist/buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.d.ts","names":[],"sources":["../src/buffer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCsB,SAAS,OAAO,cAAW,QAAA,OAAA"}
+{"version":3,"file":"buffer.d.ts","names":[],"sources":["../src/buffer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCsB,SAAS,OAAO,cAAW,QAAA,OAAA"}

package/dist/buffer.js

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-//#region src/buffer.ts
+// src/buffer.ts
 /**
 * Converts binary input to a Node.js `Buffer`.
 *
@@ -36,7 +36,6 @@ async function toBuffer(input) {
 	if (typeof input.arrayBuffer === "function") return Buffer.from(await input.arrayBuffer());
 	throw new TypeError("The provided input is not a supported binary type (Blob, Buffer, File, ArrayBuffer, or Uint8Array).");
 }
-//#endregion
 export { toBuffer };
 
 //# sourceMappingURL=buffer.js.map

package/dist/classes/enhanced-date.d.ts

@@ -1,5 +1,4 @@
 import * as dateFns from "date-fns";
-//#region src/classes/enhanced-date.d.ts
 /**
  * A mutable calendar date with chainable date-fns operations.
  *
@@ -453,5 +452,4 @@ export declare class EnhancedDate extends Date {
    */
   toSubYears(amount: number): EnhancedDate;
 }
-//#endregion
 //# sourceMappingURL=enhanced-date.d.ts.map

package/dist/classes/enhanced-date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enhanced-date.d.ts","names":[],"sources":["../../src/classes/enhanced-date.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Ba,qBAAqB;;;;SAMvB,cAAU;;;;SAOV,iBAAa;;;;SAOb,kBAAc;;;;;;;;;;;SAcd,WACH,eACA,iBACA,eAAe,QAAQ,QAAQ,OAC/B,UAAU,QAAQ,eAAY;;;;;;;;;SAa3B,QAAQ,eAAe,UAAU,QAAQ,kBAAe;;;;;;SASxD,gBAAgB,kBAAe;;;;;;;;SAW/B,IAAI,QAAQ,mBAAgB;;;;;;;;SAW5B,IAAI,QAAQ,mBAAgB;;;;SAO5B,gBAAY;;;;SAOZ,mBAAe;;;;SAOf,oBAAgB;;;;;;;;EAavB,QAAQ;;;;;;;;EAYR,SAAS;;;;;;;;EAYT,gBAAgB;;;;;;;;EAYhB,WAAW;;;;;;;;EAYX,UAAU;;;;;;;;EAYV,WAAW;;;;;;;;EAYX,SAAS;;;;;;;;EAYT,SAAS;;;;EAQT,SAAK;;;;;;;EAUL,yBAAyB,OAAO,QAAQ,QAAQ;;;;;;;EAUhD,0BAA0B,OAAO,QAAQ,QAAQ,OAAO,UAAU,QAAQ;;;;;;;EAU1E,oBAAoB,OAAO,QAAQ,QAAQ,OAAO,UAAU,QAAQ;;;;;;EASpE;;;;;;EAUA;;;;;;EAUA;;;;;;;;EAYA,UAAU,UAAU,QAAQ;;;;;;;EAW5B,OAAO,kBAAyC,UAAU,QAAQ;;;;EAOlE,oBAAoB,UAAU,QAAQ;;;;EAOtC;;;;EAOA,QAAQ,OAAO,QAAQ,QAAQ;;;;EAO/B,SAAS,OAAO,QAAQ,QAAQ;;;;EAOhC,QAAQ,OAAO,QAAQ,QAAQ;;;;EAO/B;;;;EAOA,UAAU,OAAO,QAAQ,QAAQ;;;;EAOjC,aAAa,OAAO,QAAQ,QAAQ;;;;EAOpC;;;;EAOA;;;;EAOA;;;;;;EASA;;;;;;EAUA;;;;;;EAUA;;;;;;;;EAYA,YAAY,UAAU,QAAQ;;;;;;;;EAY9B,QAAQ;;;;;;;;EAYR,SAAS;;;;;;;;EAYT,gBAAgB;;;;;;;;EAYhB,WAAW;;;;;;;;EAYX,UAAU;;;;;;;;EAYV,WAAW;;;;;;;;EAYX,SAAS;;;;;;;;EAYT,SAAS;;;;EAQT,UAAU,iBAAc;;;;EAOxB,WAAW,iBAAc;;;;EAOzB,kBAAkB,iBAAc;;;;EAOhC,aAAa,iBAAc;;;;EAO3B,YAAY,iBAAc;;;;EAO1B,aAAa,iBAAc;;;;EAO3B,WAAW,iBAAc;;;;EAOzB,WAAW,iBAAc;;;;EAOzB,UAAM;;;;EAON,cAAU;;;;EAOV,iBAAa;;;;EAOb,gBAAY;;;;EAOZ,YAAY,UAAU,QAAQ,mBAAgB;;;;EAO9C,gBAAY;;;;EAOZ,mBAAe;;;;EAOf,kBAAc;;;;EAOd,cAAc,UAAU,QAAQ,qBAAkB;;;;EAOlD,UAAU,iBAAc;;;;EAOxB,WAAW,iBAAc;;;;EAOzB,kBAAkB,iBAAc;;;;EAOhC,aAAa,iBAAc;;;;EAO3B,YAAY,iBAAc;;;;EAO1B,aAAa,iBAAc;;;;EAO3B,WAAW,iBAAc;;;;EAOzB,WAAW,iBAAc"}
+{"version":3,"file":"enhanced-date.d.ts","names":[],"sources":["../../src/classes/enhanced-date.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Ba,qBAAqB;;;;SAMvB,cAAU;;;;SAOV,iBAAa;;;;SAOb,kBAAc;;;;;;;;;;;SAcd,WACH,eACA,iBACA,eAAe,QAAQ,QAAQ,OAC/B,UAAU,QAAQ,eAAY;;;;;;;;;SAa3B,QAAQ,eAAe,UAAU,QAAQ,kBAAe;;;;;;SASxD,gBAAgB,kBAAe;;;;;;;;SAW/B,IAAI,QAAQ,mBAAgB;;;;;;;;SAW5B,IAAI,QAAQ,mBAAgB;;;;SAO5B,gBAAY;;;;SAOZ,mBAAe;;;;SAOf,oBAAgB;;;;;;;;EAavB,QAAQ;;;;;;;;EAYR,SAAS;;;;;;;;EAYT,gBAAgB;;;;;;;;EAYhB,WAAW;;;;;;;;EAYX,UAAU;;;;;;;;EAYV,WAAW;;;;;;;;EAYX,SAAS;;;;;;;;EAYT,SAAS;;;;EAQT,SAAK;;;;;;;EAUL,yBAAyB,OAAO,QAAQ,QAAQ;;;;;;;EAUhD,0BAA0B,OAAO,QAAQ,QAAQ,OAAO,UAAU,QAAQ;;;;;;;EAU1E,oBAAoB,OAAO,QAAQ,QAAQ,OAAO,UAAU,QAAQ;;;;;;EASpE;;;;;;EAUA;;;;;;EAUA;;;;;;;;EAYA,UAAU,UAAU,QAAQ;;;;;;;EAW5B,OAAO,kBAAyC,UAAU,QAAQ;;;;EAOlE,oBAAoB,UAAU,QAAQ;;;;EAOtC;;;;EAOA,QAAQ,OAAO,QAAQ,QAAQ;;;;EAO/B,SAAS,OAAO,QAAQ,QAAQ;;;;EAOhC,QAAQ,OAAO,QAAQ,QAAQ;;;;EAO/B;;;;EAOA,UAAU,OAAO,QAAQ,QAAQ;;;;EAOjC,aAAa,OAAO,QAAQ,QAAQ;;;;EAOpC;;;;EAOA;;;;EAOA;;;;;;EASA;;;;;;EAUA;;;;;;EAUA;;;;;;;;EAYA,YAAY,UAAU,QAAQ;;;;;;;;EAY9B,QAAQ;;;;;;;;EAYR,SAAS;;;;;;;;EAYT,gBAAgB;;;;;;;;EAYhB,WAAW;;;;;;;;EAYX,UAAU;;;;;;;;EAYV,WAAW;;;;;;;;EAYX,SAAS;;;;;;;;EAYT,SAAS;;;;EAQT,UAAU,iBAAc;;;;EAOxB,WAAW,iBAAc;;;;EAOzB,kBAAkB,iBAAc;;;;EAOhC,aAAa,iBAAc;;;;EAO3B,YAAY,iBAAc;;;;EAO1B,aAAa,iBAAc;;;;EAO3B,WAAW,iBAAc;;;;EAOzB,WAAW,iBAAc;;;;EAOzB,UAAM;;;;EAON,cAAU;;;;EAOV,iBAAa;;;;EAOb,gBAAY;;;;EAOZ,YAAY,UAAU,QAAQ,mBAAgB;;;;EAO9C,gBAAY;;;;EAOZ,mBAAe;;;;EAOf,kBAAc;;;;EAOd,cAAc,UAAU,QAAQ,qBAAkB;;;;EAOlD,UAAU,iBAAc;;;;EAOxB,WAAW,iBAAc;;;;EAOzB,kBAAkB,iBAAc;;;;EAOhC,aAAa,iBAAc;;;;EAO3B,YAAY,iBAAc;;;;EAO1B,aAAa,iBAAc;;;;EAO3B,WAAW,iBAAc;;;;EAOzB,WAAW,iBAAc"}

package/dist/classes/enhanced-date.js

@@ -1,5 +1,5 @@
 import * as dateFns from "date-fns";
-//#region src/classes/enhanced-date.ts
+// src/classes/enhanced-date.ts
 /**
 * A mutable calendar date with chainable date-fns operations.
 *
@@ -629,7 +629,6 @@ var EnhancedDate = class EnhancedDate extends Date {
 		return this.clone().subYears(amount);
 	}
 };
-//#endregion
 export { EnhancedDate };
 
 //# sourceMappingURL=enhanced-date.js.map

package/dist/classes/path.d.ts

@@ -1,9 +1,8 @@
 import { Buffer } from "node:buffer";
 import * as fsp from "node:fs/promises";
 import * as nodePath from "node:path";
-import { Abortable } from "node:events";
 import * as fs from "node:fs";
-//#region src/classes/path.d.ts
+import { Abortable } from "node:events";
 type DropFirstParameters<T extends (...args: any) => any> = Parameters<T> extends [any, ...infer R] ? R : never;
 /**
  * Values accepted by the `Path` constructor and path-composition methods.
@@ -359,6 +358,5 @@ export declare class Path {
    */
   writeFile(...args: DropFirstParameters<typeof fsp.writeFile>): Promise<void>;
 }
-//#endregion
 export {};
 //# sourceMappingURL=path.d.ts.map

package/dist/classes/path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path.d.ts","names":[],"sources":["../../src/classes/path.ts"],"mappings":";;;;;;KAMK,oBAAoB,cAAc,qBAAqB,WAAW,0BAA0B,KAAK;;;;YAK1F,WAAW,GAAG,WAAW;;;;;;;;;;qBAWxB;;;;;;;EAWG,eAAG,OAAO;;;;;;MAoBlB,UAAM;;;;MAON;;;;;;;;;;SAeG,OAAO,YAAY,SAAS,wBAAqB;;;;;;;;;;;;;;SAiBjD,WAAW,OAAO,aAAU;GASlC,OAAO,aAAa;;;;;;;;EAYrB,SAAS;;;;;;;;EAWT,WAAO;;;;;;;;EAWP;;;;;;;;EAWA;;;;;;;;EAWA,aAAS;;;;;;;;;;EAaT,QAAQ,OAAO,aAAU;;;;;;;;EAWzB,SAAK,SAAA;;;;;;;;;;EAaL,SAAS,IAAI,WAAQ;;;;;;;;;;;EAcrB,WAAO;EAIP;;;;;;;;;EAYA;;;;EAOA;;;;;;;;;EAYA,UAAU,MAAM,2BAA2B,IAAI,UAAO;;;;;;;;;EAYtD,cAAc,MAAM,2BAA2B,IAAI,cAAW;;;;;;;;;EAY9D,SAAS,MAAM,2BAA2B,IAAI,SAAM;;;;;;;;;EAYpD,SAAS,MAAM,2BAA2B,IAAI,SAAM;;;;;;;;;EAYpD,YAAY,MAAM,2BAA2B,IAAI,YAAS;;;;;;;;;;EAa1D,MAAM,SAAS,GAAG;IAAyB;MAAoB;EAC/D,MACI,WACK,GAAG;IAAyB;OAC7B,GAAG,cAER;EACH,MAAM,UAAU,GAAG,uBAAuB,GAAG,cAAc;;;;;;;;;EAa3D,QAAQ,MAAM,2BAA2B,IAAI,QAAK,QAAA,GAAA,SAAA;;;;;;;;;EAYlD,QACI,UACI,kBACC,GAAG;IACF;IACA;cAGP;EACH,QACI;IAGM;IACA;IACA;MAEP,QAAQ;EACX,QACI,UACI,kBACC,GAAG;IACF;IACA;cAGP,QAAQ;EACX,QACI,SAAS,GAAG;IACR;IACA;MAEL,QAAQ,GAAG;EACd,QACI;IACI;IACA;IACA;MAEL,QAAQ,GAAG,OAAO;;;;;;;;;EAarB,SACI,WACK;IACC;IACA,OAAO,GAAG;cAGjB,QAAQ;EACX,SACI,UACK;IACC,UAAU;IACV,OAAO,GAAG;OAEZ,iBACL;EACH,SACI,WAEQ,YACA,GAAG;IACD,OAAO,GAAG;OAEd,wBAEP,QAAQ;;;;;;;;;;;EAeX,OAAO,SAAS,WAAQ;;;;;;;;;EAYxB,MAAM,MAAM,2BAA2B,IAAI,MAAG;;;;;;;;;EAY9C,SAAS,MAAM,2BAA2B,IAAI,SAAM;;;;;;;;;;EAapD,KACI,OAAO,GAAG;IACN;IACA;MAEL,QAAQ,GAAG;EACd,KACI,MAAM,GAAG;IACL;IACA;MAEL,QAAQ,GAAG;EACd,KACI,MAAM,GAAG;IACL;IACA;MAEL,QAAQ,GAAG;EACd,KACI,MAAM,GAAG;IACL;IACA;MAEL,QAAQ,GAAG;EACd,KAAK,MAAM,GAAG;IAAgB;MAA0B,QAAQ,GAAG,cAAc,GAAG;EACpF,KAAK,OAAO,GAAG,cAAc,QAAQ,GAAG,cAAc,GAAG;;;;;;;;;EAwBzD,YAAY,MAAM,2BAA2B,IAAI,YAAS;;;;;;;;;EAY1D,UAAM;;;;;;;;;EAYN,aAAa,MAAM,2BAA2B,IAAI,aAAU"}
+{"version":3,"file":"path.d.ts","names":[],"sources":["../../src/classes/path.ts"],"mappings":";;;;;KAMK,oBAAoB,cAAc,qBAAqB,WAAW,0BAA0B,KAAK;;;;YAK1F,WAAW,GAAG,WAAW;;;;;;;;;;qBAWxB;;;;;;;EAWG,eAAG,OAAO;;;;;;MAoBlB,UAAM;;;;MAON;;;;;;;;;;SAeG,OAAO,YAAY,SAAS,wBAAqB;;;;;;;;;;;;;;SAiBjD,WAAW,OAAO,aAAU;GASlC,OAAO,aAAa;;;;;;;;EAYrB,SAAS;;;;;;;;EAWT,WAAO;;;;;;;;EAWP;;;;;;;;EAWA;;;;;;;;EAWA,aAAS;;;;;;;;;;EAaT,QAAQ,OAAO,aAAU;;;;;;;;EAWzB,SAAK,SAAA;;;;;;;;;;EAaL,SAAS,IAAI,WAAQ;;;;;;;;;;;EAcrB,WAAO;EAIP;;;;;;;;;EAYA;;;;EAOA;;;;;;;;;EAYA,UAAU,MAAM,2BAA2B,IAAI,UAAO;;;;;;;;;EAYtD,cAAc,MAAM,2BAA2B,IAAI,cAAW;;;;;;;;;EAY9D,SAAS,MAAM,2BAA2B,IAAI,SAAM;;;;;;;;;EAYpD,SAAS,MAAM,2BAA2B,IAAI,SAAM;;;;;;;;;EAYpD,YAAY,MAAM,2BAA2B,IAAI,YAAS;;;;;;;;;;EAa1D,MAAM,SAAS,GAAG;IAAyB;MAAoB;EAC/D,MACI,WACK,GAAG;IAAyB;OAC7B,GAAG,cAER;EACH,MAAM,UAAU,GAAG,uBAAuB,GAAG,cAAc;;;;;;;;;EAa3D,QAAQ,MAAM,2BAA2B,IAAI,QAAK,QAAA,GAAA,SAAA;;;;;;;;;EAYlD,QACI,UACI,kBACC,GAAG;IACF;IACA;cAGP;EACH,QACI;IAGM;IACA;IACA;MAEP,QAAQ;EACX,QACI,UACI,kBACC,GAAG;IACF;IACA;cAGP,QAAQ;EACX,QACI,SAAS,GAAG;IACR;IACA;MAEL,QAAQ,GAAG;EACd,QACI;IACI;IACA;IACA;MAEL,QAAQ,GAAG,OAAO;;;;;;;;;EAarB,SACI,WACK;IACC;IACA,OAAO,GAAG;cAGjB,QAAQ;EACX,SACI,UACK;IACC,UAAU;IACV,OAAO,GAAG;OAEZ,iBACL;EACH,SACI,WAEQ,YACA,GAAG;IACD,OAAO,GAAG;OAEd,wBAEP,QAAQ;;;;;;;;;;;EAeX,OAAO,SAAS,WAAQ;;;;;;;;;EAYxB,MAAM,MAAM,2BAA2B,IAAI,MAAG;;;;;;;;;EAY9C,SAAS,MAAM,2BAA2B,IAAI,SAAM;;;;;;;;;;EAapD,KACI,OAAO,GAAG;IACN;IACA;MAEL,QAAQ,GAAG;EACd,KACI,MAAM,GAAG;IACL;IACA;MAEL,QAAQ,GAAG;EACd,KACI,MAAM,GAAG;IACL;IACA;MAEL,QAAQ,GAAG;EACd,KACI,MAAM,GAAG;IACL;IACA;MAEL,QAAQ,GAAG;EACd,KAAK,MAAM,GAAG;IAAgB;MAA0B,QAAQ,GAAG,cAAc,GAAG;EACpF,KAAK,OAAO,GAAG,cAAc,QAAQ,GAAG,cAAc,GAAG;;;;;;;;;EAwBzD,YAAY,MAAM,2BAA2B,IAAI,YAAS;;;;;;;;;EAY1D,UAAM;;;;;;;;;EAYN,aAAa,MAAM,2BAA2B,IAAI,aAAU"}

package/dist/classes/path.js

@@ -1,6 +1,6 @@
 import * as fsp from "node:fs/promises";
 import * as nodePath from "node:path";
-//#region src/classes/path.ts
+// src/classes/path.ts
 /**
 * An immutable file system path with Node.js path and file operations.
 *
@@ -344,7 +344,6 @@ var Path = class Path {
 		return fsp.writeFile(this.#value, ...args);
 	}
 };
-//#endregion
 export { Path };
 
 //# sourceMappingURL=path.js.map

package/dist/classes/precision-number.d.ts

@@ -1,5 +1,4 @@
 import { Decimal } from "decimal.js";
-//#region src/classes/precision-number.d.ts
 /**
  * Values accepted by `PrecisionNumber` constructors and arithmetic methods.
  */
@@ -262,5 +261,4 @@ export declare class PrecisionNumber {
    */
   toTimes(value: PrecisionNumberValue): PrecisionNumber;
 }
-//#endregion
 //# sourceMappingURL=precision-number.d.ts.map

package/dist/classes/precision-number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"precision-number.d.ts","names":[],"sources":["../../src/classes/precision-number.ts"],"mappings":";;;;;YAKY,uBAAuB,QAAQ,QAAQ;EAAoB;;;;;;;;;;;;;;;;;;;;;;;;qBAwB1D;;;;;;;;;EAgBL,YAAA,QAAO,sBACP,wBACA,WAAU,QAAQ;;;;MAqBlB;;;;MAOA,YAAQ,QAAA;;;;MAOR;;;;;;;;;;SAeG,QACH,OAAO,sBACP,wBACA,WAAU,QAAQ;;;;;;GAmBrB,OAAO,aAAa;;;;;;EAUrB;;;;;;;;;EAaA;;;;;;;;;;;EAeA,MAAM,KAAK,sBAAsB,KAAK;;;;EAWtC,SAAK;;;;;;;;EAWL,UAAU,OAAO;;;;;;;;EAYjB,OAAO,OAAO;;;;;;;;;EAYd;;;;EAQA,GAAG,OAAO;;;;EAOV,IAAI,OAAO;;;;EAOX;;;;EAOA;;;;EAOA;;;;EAOA;;;;EAOA;;;;EAOA;;;;EAOA,GAAG,OAAO;;;;EAOV,IAAI,OAAO;;;;EAOX,MAAM,OAAO;;;;;;;;EAYb,OAAO,OAAO;;;;EAQd;;;;EAQA,KAAK,OAAO;;;;;;;;EAYZ,IAAI,OAAO;;;;EAQX,MAAM,OAAO;;;;EAQb,mBAAe;;;;EAOf,UAAM;;;;;;;;;EAYN,UAAU,KAAK,sBAAsB,KAAK,uBAAoB;;;;EAO9D,YAAY,OAAO,uBAAoB;;;;EAWvC,WAAO;;;;EAOP;;;;EAOA,QAAQ,OAAO,uBAAoB;;;;EAWnC,SAAS,OAAO,uBAAoB;;;;EAWpC,aAAS;;;;EAOT,OAAO,OAAO,uBAAoB;;;;EAOlC,MAAM,OAAO,uBAAoB;;;;;;;EAUjC;;;;EAOA;;;;EAOA,QAAQ,wBAA6C,WAAU,QAAQ;;;;EAOvE,QAAQ,OAAO,uBAAoB"}
+{"version":3,"file":"precision-number.d.ts","names":[],"sources":["../../src/classes/precision-number.ts"],"mappings":";;;;YAKY,uBAAuB,QAAQ,QAAQ;EAAoB;;;;;;;;;;;;;;;;;;;;;;;;qBAwB1D;;;;;;;;;EAgBL,YAAA,QAAO,sBACP,wBACA,WAAU,QAAQ;;;;MAqBlB;;;;MAOA,YAAQ,QAAA;;;;MAOR;;;;;;;;;;SAeG,QACH,OAAO,sBACP,wBACA,WAAU,QAAQ;;;;;;GAmBrB,OAAO,aAAa;;;;;;EAUrB;;;;;;;;;EAaA;;;;;;;;;;;EAeA,MAAM,KAAK,sBAAsB,KAAK;;;;EAWtC,SAAK;;;;;;;;EAWL,UAAU,OAAO;;;;;;;;EAYjB,OAAO,OAAO;;;;;;;;;EAYd;;;;EAQA,GAAG,OAAO;;;;EAOV,IAAI,OAAO;;;;EAOX;;;;EAOA;;;;EAOA;;;;EAOA;;;;EAOA;;;;EAOA;;;;EAOA,GAAG,OAAO;;;;EAOV,IAAI,OAAO;;;;EAOX,MAAM,OAAO;;;;;;;;EAYb,OAAO,OAAO;;;;EAQd;;;;EAQA,KAAK,OAAO;;;;;;;;EAYZ,IAAI,OAAO;;;;EAQX,MAAM,OAAO;;;;EAQb,mBAAe;;;;EAOf,UAAM;;;;;;;;;EAYN,UAAU,KAAK,sBAAsB,KAAK,uBAAoB;;;;EAO9D,YAAY,OAAO,uBAAoB;;;;EAWvC,WAAO;;;;EAOP;;;;EAOA,QAAQ,OAAO,uBAAoB;;;;EAWnC,SAAS,OAAO,uBAAoB;;;;EAWpC,aAAS;;;;EAOT,OAAO,OAAO,uBAAoB;;;;EAOlC,MAAM,OAAO,uBAAoB;;;;;;;EAUjC;;;;EAOA;;;;EAOA,QAAQ,wBAA6C,WAAU,QAAQ;;;;EAOvE,QAAQ,OAAO,uBAAoB"}

package/dist/classes/precision-number.js

@@ -1,5 +1,5 @@
 import { Decimal } from "decimal.js";
-//#region src/classes/precision-number.ts
+// src/classes/precision-number.ts
 /**
 * A fixed-decimal number with mutable and immutable arithmetic operations.
 *
@@ -375,7 +375,6 @@ var PrecisionNumber = class PrecisionNumber {
 		return new PrecisionNumber(this.#decimal.times(this.#valueToString(value)), this.#decimalPlaces, this.#rounding);
 	}
 };
-//#endregion
 export { PrecisionNumber };
 
 //# sourceMappingURL=precision-number.js.map

package/dist/clipboard.d.ts

@@ -1,4 +1,3 @@
-//#region src/clipboard.d.ts
 type CopyResult = {
   error: unknown;
   ok: false;
@@ -61,6 +60,5 @@ export declare function copyBlobToClipboard(blob: Blob, options?: ClipboardItemO
  * ```
  */
 export declare function copyTextToClipboard(text: string): Promise<CopyResult>;
-//#endregion
 export {};
 //# sourceMappingURL=clipboard.d.ts.map

package/dist/clipboard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clipboard.d.ts","names":[],"sources":["../src/clipboard.ts"],"mappings":";KAAK;EACC;EAAgB;;EAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BgB,oBAAoB,MAAM,MAAM,UAAU,uBAAuB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8CzE,oBAAoB,eAAe,QAAQ"}
+{"version":3,"file":"clipboard.d.ts","names":[],"sources":["../src/clipboard.ts"],"mappings":"A,KAAK;EACC;EAAgB;;EAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BgB,oBAAoB,MAAM,MAAM,UAAU,uBAAuB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8CzE,oBAAoB,eAAe,QAAQ"}

package/dist/clipboard.js

@@ -1,4 +1,4 @@
-//#region src/clipboard.ts
+// src/clipboard.ts
 /**
 * Attempts to copy a blob to the browser clipboard.
 *
@@ -80,7 +80,6 @@ async function copyTextToClipboard(text) {
 		};
 	}
 }
-//#endregion
 export { copyBlobToClipboard, copyTextToClipboard };
 
 //# sourceMappingURL=clipboard.js.map

package/dist/crypto-hash.d.ts

@@ -1,5 +1,4 @@
 import { BinaryLike } from "node:crypto";
-//#region src/crypto-hash.d.ts
 /**
  * Computes the MD5 hash of the given data.
  *
@@ -165,5 +164,4 @@ export declare function cryptoSha3512(data: BinaryLike, outputEncoding?: BufferE
  * ```
  */
 export declare function cryptoSha3512ToBuffer(data: BinaryLike): NonSharedBuffer;
-//#endregion
 //# sourceMappingURL=crypto-hash.d.ts.map

package/dist/crypto-hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crypto-hash.d.ts","names":[],"sources":["../src/crypto-hash.ts"],"mappings":";;;;;;;;;;;;;;;;;;wBAoBgB,UAAU,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmB5C,kBAAkB,MAAM,aAAU;;;;;;;;;;;;;;;;;wBAoBlC,cAAc,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmBhD,sBAAsB,MAAM,aAAU;;;;;;;;;;;;;;;;;wBAoBtC,cAAc,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmBhD,sBAAsB,MAAM,aAAU;;;;;;;;;;;;;;;;;wBAoBtC,cAAc,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmBhD,sBAAsB,MAAM,aAAU;;;;;;;;;;;;;;;;;wBAoBtC,cAAc,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmBhD,sBAAsB,MAAM,aAAU"}
+{"version":3,"file":"crypto-hash.d.ts","names":[],"sources":["../src/crypto-hash.ts"],"mappings":";;;;;;;;;;;;;;;;;wBAoBgB,UAAU,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmB5C,kBAAkB,MAAM,aAAU;;;;;;;;;;;;;;;;;wBAoBlC,cAAc,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmBhD,sBAAsB,MAAM,aAAU;;;;;;;;;;;;;;;;;wBAoBtC,cAAc,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmBhD,sBAAsB,MAAM,aAAU;;;;;;;;;;;;;;;;;wBAoBtC,cAAc,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmBhD,sBAAsB,MAAM,aAAU;;;;;;;;;;;;;;;;;wBAoBtC,cAAc,MAAM,YAAY,iBAAgB;;;;;;;;;;;;;;;;wBAmBhD,sBAAsB,MAAM,aAAU"}

package/dist/crypto-hash.js

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
-//#region src/crypto-hash.ts
+// src/crypto-hash.ts
 /**
 * Computes the MD5 hash of the given data.
 *
@@ -189,7 +189,6 @@ function cryptoSha3512ToBuffer(data) {
 function normalizeHashData(data) {
 	return typeof data === "string" || ArrayBuffer.isView(data) ? data : Buffer.from(data);
 }
-//#endregion
 export { cryptoMd5, cryptoMd5ToBuffer, cryptoSha3224, cryptoSha3224ToBuffer, cryptoSha3256, cryptoSha3256ToBuffer, cryptoSha3384, cryptoSha3384ToBuffer, cryptoSha3512, cryptoSha3512ToBuffer };
 
 //# sourceMappingURL=crypto-hash.js.map

package/dist/datetime.d.ts

@@ -1,6 +1,5 @@
 import { EnhancedDate } from "./classes/enhanced-date.js";
 import * as dateFns from "date-fns";
-//#region src/datetime.d.ts
 export type DateRangeType = 'lastMonth' | 'lastWeek' | 'thisMonth' | 'thisWeek' | 'today' | 'yesterday';
 /**
  * Formats a date using a date-fns pattern without changing the input.
@@ -67,5 +66,4 @@ export declare function getDateRangeFromDate(date: Date, type: DateRangeType, op
  * @returns A new `EnhancedDate` at local midnight on the selected day.
  */
 export declare function getMidnightDateFromToday(offsetDays?: number): EnhancedDate;
-//#endregion
 //# sourceMappingURL=datetime.d.ts.map

package/dist/datetime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"datetime.d.ts","names":[],"sources":["../src/datetime.ts"],"mappings":";;;YAIY;;;;;;;;;;;;;;;;;;;;;;;wBAwBI,WACZ,MAAM,QAAQ,QAAQ,OACtB,iBACA,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkCN,qBACZ,MAAM,MACN,MAAM,eACN;EACI;EACA,eAAe,QAAQ;;;;;;;;;;;;wBA8Df,yBAAyB,sBAAsB"}
+{"version":3,"file":"datetime.d.ts","names":[],"sources":["../src/datetime.ts"],"mappings":";;YAIY;;;;;;;;;;;;;;;;;;;;;;;wBAwBI,WACZ,MAAM,QAAQ,QAAQ,OACtB,iBACA,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkCN,qBACZ,MAAM,MACN,MAAM,eACN;EACI;EACA,eAAe,QAAQ;;;;;;;;;;;;wBA8Df,yBAAyB,sBAAsB"}

package/dist/datetime.js

@@ -1,6 +1,6 @@
 import { EnhancedDate } from "./classes/enhanced-date.js";
 import * as dateFns from "date-fns";
-//#region src/datetime.ts
+// src/datetime.ts
 /**
 * Formats a date using a date-fns pattern without changing the input.
 *
@@ -109,7 +109,6 @@ function getDateRangeFromDate(date, type, options) {
 function getMidnightDateFromToday(offsetDays = 0) {
 	return new EnhancedDate().addDays(offsetDays).startOfDay();
 }
-//#endregion
 export { formatDate, getDateRangeFromDate, getMidnightDateFromToday };
 
 //# sourceMappingURL=datetime.js.map

package/dist/element-plus.d.ts

@@ -1,6 +1,5 @@
 import { RuleType } from "async-validator";
 import { FormItemRule } from "element-plus";
-//#region src/element-plus.d.ts
 export type DoNotRemoveOrUseThisType = RuleType;
 /**
  * Creates a new Element Plus form validation rule with overridable defaults.
@@ -26,5 +25,4 @@ export type DoNotRemoveOrUseThisType = RuleType;
  * ```
  */
 export declare function createElFormItemRuleWithDefaults(message: FormItemRule['message'], options?: FormItemRule): FormItemRule;
-//#endregion
 //# sourceMappingURL=element-plus.d.ts.map

package/dist/element-plus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"element-plus.d.ts","names":[],"sources":["../src/element-plus.ts"],"mappings":";;;YAGY,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;wBAyBvB,iCACZ,SAAS,yBACT,UAAS,eACV"}
+{"version":3,"file":"element-plus.d.ts","names":[],"sources":["../src/element-plus.ts"],"mappings":";;YAGY,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;wBAyBvB,iCACZ,SAAS,yBACT,UAAS,eACV"}

package/dist/element-plus.js

@@ -1,4 +1,4 @@
-//#region src/element-plus.ts
+// src/element-plus.ts
 /**
 * Creates a new Element Plus form validation rule with overridable defaults.
 *
@@ -31,7 +31,6 @@ function createElFormItemRuleWithDefaults(message, options = {}) {
 		type: options.type ?? "string"
 	};
 }
-//#endregion
 export { createElFormItemRuleWithDefaults };
 
 //# sourceMappingURL=element-plus.js.map

package/dist/enum.d.ts

@@ -1,4 +1,3 @@
-//#region src/enum.d.ts
 /**
  * Extracts only the numeric values from an enumeration-like object.
  *
@@ -98,5 +97,4 @@ export declare function getEnumStringValues<T extends Record<string, any>>(enumO
  * ```
  */
 export declare function getEnumValues<T extends Record<string, any>>(enumObject: T): (T[keyof T])[];
-//#endregion
 //# sourceMappingURL=enum.d.ts.map

package/dist/enum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enum.d.ts","names":[],"sources":["../src/enum.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;wBAwBgB,oBAAoB,UAAU,qBAAqB,YAAY,IAAI,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;wBA4BnF,oBAAoB,UAAU,qBAAqB,YAAY,IAAI,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoDnF,cAAc,UAAU,qBAAqB,YAAY,KAAK,QAAQ"}
+{"version":3,"file":"enum.d.ts","names":[],"sources":["../src/enum.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;wBAwBgB,oBAAoB,UAAU,qBAAqB,YAAY,IAAI,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;wBA4BnF,oBAAoB,UAAU,qBAAqB,YAAY,IAAI,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAoDnF,cAAc,UAAU,qBAAqB,YAAY,KAAK,QAAQ"}

package/dist/enum.js

@@ -1,4 +1,4 @@
-//#region src/enum.ts
+// src/enum.ts
 /**
 * Extracts only the numeric values from an enumeration-like object.
 *
@@ -106,7 +106,6 @@ function getEnumValues(enumObject) {
 	if (!values.some((value) => typeof value === "number")) return values;
 	return Object.keys(enumObject).filter((key) => Number.isNaN(Number(key))).map((key) => enumObject[key]);
 }
-//#endregion
 export { getEnumNumberValues, getEnumStringValues, getEnumValues };
 
 //# sourceMappingURL=enum.js.map

package/dist/env.d.ts

@@ -1,4 +1,3 @@
-//#region src/env.d.ts
 /**
  * Custom error class for handling missing environment variables.
  *
@@ -47,5 +46,4 @@ export declare class EnvironmentNotFoundError extends Error {
  * ```
  */
 export declare function checkAndGetEnvValue(key: string): string;
-//#endregion
 //# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","names":[],"sources":["../src/env.ts"],"mappings":";;;;;;;qBAMa,iCAAiC;WACjC;;;;;;EAOG,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwCA,oBAAoB"}
+{"version":3,"file":"env.d.ts","names":[],"sources":["../src/env.ts"],"mappings":";;;;;;qBAMa,iCAAiC;WACjC;;;;;;EAOG,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwCA,oBAAoB"}

package/dist/env.js

@@ -1,4 +1,4 @@
-//#region src/env.ts
+// src/env.ts
 /**
 * Custom error class for handling missing environment variables.
 *
@@ -55,7 +55,6 @@ function checkAndGetEnvValue(key) {
 	if (process.env[key] === void 0) throw new EnvironmentNotFoundError(key);
 	return process.env[key];
 }
-//#endregion
 export { EnvironmentNotFoundError, checkAndGetEnvValue };
 
 //# sourceMappingURL=env.js.map

package/dist/event-awaiter.d.ts

@@ -1,4 +1,3 @@
-//#region src/event-awaiter.d.ts
 /**
  * An asynchronous keyed event rendezvous for one or more waiting consumers.
  *
@@ -75,5 +74,4 @@ export declare class EventAwaiter<T> {
    */
   waitLatest(key: string, timeoutMs?: number, signal?: AbortSignal): Promise<T | undefined>;
 }
-//#endregion
 //# sourceMappingURL=event-awaiter.d.ts.map

package/dist/event-awaiter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-awaiter.d.ts","names":[],"sources":["../src/event-awaiter.ts"],"mappings":";;;;;;;;;;;;qBAWa,aAAa;;;;;;;;EAYtB,QAAQ,aAAa,OAAO;;;;;;EAa5B,WAAW,QAAO;;;;;;;;;;;;;;;;;;;;EAwBlB,KAAK,aAAa,oBAAoB,8BAA8B,SAAS,cAAW,QAAA;;;;;;;;;;;;;;EA8DxF,cAAc,aAAa,oBAAoB,SAAS,cAAW,QAAA;;;;;;;;;;;;;;;EAkBnE,WAAW,aAAa,oBAAoB,SAAS,cAAW,QAAA"}
+{"version":3,"file":"event-awaiter.d.ts","names":[],"sources":["../src/event-awaiter.ts"],"mappings":";;;;;;;;;;;qBAWa,aAAa;;;;;;;;EAYtB,QAAQ,aAAa,OAAO;;;;;;EAa5B,WAAW,QAAO;;;;;;;;;;;;;;;;;;;;EAwBlB,KAAK,aAAa,oBAAoB,8BAA8B,SAAS,cAAW,QAAA;;;;;;;;;;;;;;EA8DxF,cAAc,aAAa,oBAAoB,SAAS,cAAW,QAAA;;;;;;;;;;;;;;;EAkBnE,WAAW,aAAa,oBAAoB,SAAS,cAAW,QAAA"}

package/dist/event-awaiter.js

@@ -1,4 +1,4 @@
-//#region src/event-awaiter.ts
+// src/event-awaiter.ts
 /**
 * An asynchronous keyed event rendezvous for one or more waiting consumers.
 *
@@ -119,7 +119,6 @@ var EventAwaiter = class {
 		return this.wait(key, timeoutMs, "override", signal);
 	}
 };
-//#endregion
 export { EventAwaiter };
 
 //# sourceMappingURL=event-awaiter.js.map

package/dist/file.d.ts

@@ -1,5 +1,4 @@
 import { BinaryInput } from "./types/index.js";
-//#region src/file.d.ts
 /**
  * Detects a lowercase MIME type from binary content rather than its name or declared type.
  *
@@ -23,5 +22,4 @@ import { BinaryInput } from "./types/index.js";
  * ```
  */
 export declare function getFileMimeType(input: BinaryInput): Promise<string | undefined>;
-//#endregion
 //# sourceMappingURL=file.d.ts.map

package/dist/file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","names":[],"sources":["../src/file.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;wBA6BsB,gBAAgB,OAAO,cAAW"}
+{"version":3,"file":"file.d.ts","names":[],"sources":["../src/file.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;wBA6BsB,gBAAgB,OAAO,cAAW"}

package/dist/file.js

@@ -1,5 +1,5 @@
 import { fileTypeFromBlob, fileTypeFromBuffer } from "file-type";
-//#region src/file.ts
+// src/file.ts
 /**
 * Detects a lowercase MIME type from binary content rather than its name or declared type.
 *
@@ -25,7 +25,6 @@ import { fileTypeFromBlob, fileTypeFromBuffer } from "file-type";
 async function getFileMimeType(input) {
 	return (input instanceof ArrayBuffer || input instanceof Uint8Array ? await fileTypeFromBuffer(input) : await fileTypeFromBlob(input))?.mime.toLowerCase();
 }
-//#endregion
 export { getFileMimeType };
 
 //# sourceMappingURL=file.js.map

package/dist/general.d.ts

@@ -1,4 +1,3 @@
-//#region src/general.d.ts
 /**
  * Returns the first array element or the input value, with a nullish fallback.
  *
@@ -32,5 +31,4 @@
  */
 export declare function extractFirstValue<T>(value: T | T[]): T | undefined;
 export declare function extractFirstValue<T, D>(value: T | T[], defaultValue: D): D | NonNullable<T>;
-//#endregion
 //# sourceMappingURL=general.d.ts.map

package/dist/general.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"general.d.ts","names":[],"sources":["../src/general.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCgB,kBAAkB,GAAG,OAAO,IAAI,MAAM;wBACtC,kBAAkB,GAAG,GAAG,OAAO,IAAI,KAAK,cAAc,IAAI,IAAI,YAAY"}
+{"version":3,"file":"general.d.ts","names":[],"sources":["../src/general.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCgB,kBAAkB,GAAG,OAAO,IAAI,MAAM;wBACtC,kBAAkB,GAAG,GAAG,OAAO,IAAI,KAAK,cAAc,IAAI,IAAI,YAAY"}

package/dist/general.js

@@ -1,8 +1,7 @@
-//#region src/general.ts
+// src/general.ts
 function extractFirstValue(value, defaultValue) {
 	return (Array.isArray(value) ? value[0] : value) ?? defaultValue;
 }
-//#endregion
 export { extractFirstValue };
 
 //# sourceMappingURL=general.js.map

package/dist/hash.d.ts

@@ -1,4 +1,3 @@
-//#region src/hash.d.ts
 /**
  * Computes the SHA-3 hash of the given data using the 224-bit digest.
  *
@@ -63,5 +62,4 @@ export declare function sha3384(data: string | Uint8Array): string;
  * ```
  */
 export declare function sha3512(data: string | Uint8Array): string;
-//#endregion
 //# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","names":[],"sources":["../src/hash.ts"],"mappings":";;;;;;;;;;;;;;;;wBA0BgB,QAAQ,eAAe;;;;;;;;;;;;;;;;wBAmBvB,QAAQ,eAAe;;;;;;;;;;;;;;;;wBAmBvB,QAAQ,eAAe;;;;;;;;;;;;;;;;wBAmBvB,QAAQ,eAAe"}
+{"version":3,"file":"hash.d.ts","names":[],"sources":["../src/hash.ts"],"mappings":";;;;;;;;;;;;;;;wBA0BgB,QAAQ,eAAe;;;;;;;;;;;;;;;;wBAmBvB,QAAQ,eAAe;;;;;;;;;;;;;;;;wBAmBvB,QAAQ,eAAe;;;;;;;;;;;;;;;;wBAmBvB,QAAQ,eAAe"}

package/dist/hash.js

@@ -1,6 +1,6 @@
 import { sha3_224, sha3_256, sha3_384, sha3_512 } from "@noble/hashes/sha3.js";
 import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
-//#region src/hash.ts
+// src/hash.ts
 /**
 * Computes the SHA-3 hash of the given data using the 224-bit digest.
 *
@@ -73,7 +73,6 @@ function sha3384(data) {
 function sha3512(data) {
 	return bytesToHex(sha3_512(typeof data === "string" ? utf8ToBytes(data) : data));
 }
-//#endregion
 export { sha3224, sha3256, sha3384, sha3512 };
 
 //# sourceMappingURL=hash.js.map

package/dist/logger/_internals/formatter.d.ts

@@ -0,0 +1,13 @@
+import { LoggerRecord } from "./types.js";
+/** Native console formatting keeps user strings literal and objects expandable. */
+export declare function formatLoggerConsoleArgs(record: LoggerRecord): unknown[];
+/** Keeps data arguments intact so browser developer tools can expand objects. */
+export declare function formatLoggerParts(record: LoggerRecord, colors?: boolean): unknown[];
+/** Fixed local-time representation, deliberately without a per-second cache. */
+export declare function formatLoggerTime(date: Date): string;
+/** Use native terminal detection; redirected streams still honor FORCE_COLOR. */
+export declare function supportsLoggerColor(target: {
+  hasColors?: () => boolean;
+  isTTY?: boolean;
+}): boolean;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/logger/_internals/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","names":[],"sources":["../../../src/logger/_internals/formatter.ts"],"mappings":";;wBASgB,wBAAwB,QAAQ;;wBAiChC,kBAAkB,QAAQ,cAAc;;wBAYxC,iBAAiB,MAAM;;wBAQvB,oBAAoB;EAAU;EAA2B"}

package/dist/logger/_internals/formatter.js

@@ -0,0 +1,57 @@
+import { getLoggerStreamName, loggerMethods } from "./levels.js";
+// src/logger/_internals/formatter.ts
+/** Native console formatting keeps user strings literal and objects expandable. */
+function formatLoggerConsoleArgs(record) {
+	if (typeof process !== "undefined" && process.versions?.node) {
+		const target = process[getLoggerStreamName(record.type)];
+		const parts = formatLoggerParts(record, supportsLoggerColor(target));
+		return [parts.map((part) => typeof part === "string" ? "%s" : "%O").join(" "), ...parts];
+	}
+	const format = [];
+	const args = [];
+	const decorate = (text, color) => {
+		format.push("%c%s%c");
+		args.push(`color: ${color}`, text, "");
+	};
+	if (record.icons) decorate(loggerMethods[record.type].icon, loggerMethods[record.type].cssColor);
+	if (record.timestamp) decorate(formatLoggerTime(record.date), "#808080");
+	if (record.prefix) decorate(record.prefix, "#0891b2");
+	for (const arg of record.args) {
+		format.push(typeof arg === "string" ? "%s" : "%o");
+		args.push(arg);
+	}
+	if (record.suffix) decorate(record.suffix, "#0891b2");
+	return [format.join(" "), ...args];
+}
+/** Keeps data arguments intact so browser developer tools can expand objects. */
+function formatLoggerParts(record, colors = false) {
+	const parts = [];
+	const paint = (text, color) => colors ? `\u001B[${color}m${text}\u001B[0m` : text;
+	if (record.icons) parts.push(paint(loggerMethods[record.type].icon, loggerMethods[record.type].ansiColor));
+	if (record.timestamp) parts.push(paint(formatLoggerTime(record.date), "90"));
+	if (record.prefix) parts.push(paint(record.prefix, "36"));
+	parts.push(...record.args);
+	if (record.suffix) parts.push(paint(record.suffix, "36"));
+	return parts;
+}
+/** Fixed local-time representation, deliberately without a per-second cache. */
+function formatLoggerTime(date) {
+	const pad = (value, width = 2) => String(value).padStart(width, "0");
+	return `[${`${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`} ${`${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`}.${pad(date.getMilliseconds(), 3)}]`;
+}
+/** Use native terminal detection; redirected streams still honor FORCE_COLOR. */
+function supportsLoggerColor(target) {
+	if (target.hasColors) return target.hasColors();
+	const forced = process.env.FORCE_COLOR;
+	if (forced !== void 0) return [
+		"",
+		"1",
+		"2",
+		"3",
+		"true"
+	].includes(forced);
+	return Boolean(target.isTTY) && !process.env.NO_COLOR && !process.env.NODE_DISABLE_COLORS && process.env.TERM !== "dumb";
+}
+export { formatLoggerConsoleArgs, formatLoggerParts, formatLoggerTime, supportsLoggerColor };
+
+//# sourceMappingURL=formatter.js.map

package/dist/logger/_internals/formatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.js","names":[],"sources":["../../../src/logger/_internals/formatter.ts"],"sourcesContent":["import {\n    getLoggerStreamName,\n    loggerMethods,\n} from './levels';\nimport type { LoggerRecord } from './types';\n\n// Functions\n\n/** Native console formatting keeps user strings literal and objects expandable. */\nexport function formatLoggerConsoleArgs(record: LoggerRecord): unknown[] {\n    if (typeof process !== 'undefined' && process.versions?.node) {\n        const target = process[getLoggerStreamName(record.type)];\n        const parts = formatLoggerParts(record, supportsLoggerColor(target));\n        return [\n            parts.map((part) => typeof part === 'string' ? '%s' : '%O').join(' '),\n            ...parts,\n        ];\n    }\n\n    const format: string[] = [];\n    const args: unknown[] = [];\n    const decorate = (text: string, color: string) => {\n        format.push('%c%s%c');\n        args.push(`color: ${color}`, text, '');\n    };\n\n    if (record.icons) decorate(loggerMethods[record.type].icon, loggerMethods[record.type].cssColor);\n    if (record.timestamp) decorate(formatLoggerTime(record.date), '#808080');\n    if (record.prefix) decorate(record.prefix, '#0891b2');\n    for (const arg of record.args) {\n        format.push(typeof arg === 'string' ? '%s' : '%o');\n        args.push(arg);\n    }\n\n    if (record.suffix) decorate(record.suffix, '#0891b2');\n    return [\n        format.join(' '),\n        ...args,\n    ];\n}\n\n/** Keeps data arguments intact so browser developer tools can expand objects. */\nexport function formatLoggerParts(record: LoggerRecord, colors = false): unknown[] {\n    const parts: unknown[] = [];\n    const paint = (text: string, color: string) => colors ? `\\u001B[${color}m${text}\\u001B[0m` : text;\n    if (record.icons) parts.push(paint(loggerMethods[record.type].icon, loggerMethods[record.type].ansiColor));\n    if (record.timestamp) parts.push(paint(formatLoggerTime(record.date), '90'));\n    if (record.prefix) parts.push(paint(record.prefix, '36'));\n    parts.push(...record.args);\n    if (record.suffix) parts.push(paint(record.suffix, '36'));\n    return parts;\n}\n\n/** Fixed local-time representation, deliberately without a per-second cache. */\nexport function formatLoggerTime(date: Date): string {\n    const pad = (value: number, width = 2) => String(value).padStart(width, '0');\n    const day = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;\n    const time = `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;\n    return `[${day} ${time}.${pad(date.getMilliseconds(), 3)}]`;\n}\n\n/** Use native terminal detection; redirected streams still honor FORCE_COLOR. */\nexport function supportsLoggerColor(target: { hasColors?: () => boolean; isTTY?: boolean }): boolean {\n    if (target.hasColors) return target.hasColors();\n    const forced = process.env.FORCE_COLOR;\n    if (forced !== undefined) {\n        return [\n            '',\n            '1',\n            '2',\n            '3',\n            'true',\n        ].includes(forced);\n    }\n\n    return Boolean(target.isTTY)\n      && !process.env.NO_COLOR\n      && !process.env.NODE_DISABLE_COLORS\n      && process.env.TERM !== 'dumb';\n}\n"],"mappings":";;;AASA,SAAgB,wBAAwB,QAAiC;CACrE,IAAI,OAAO,YAAY,eAAe,QAAQ,UAAU,MAAM;EAC1D,MAAM,SAAS,QAAQ,oBAAoB,OAAO,IAAI;EACtD,MAAM,QAAQ,kBAAkB,QAAQ,oBAAoB,MAAM,CAAC;EACnE,OAAO,CACH,MAAM,KAAK,SAAS,OAAO,SAAS,WAAW,OAAO,IAAI,CAAC,CAAC,KAAK,GAAG,GACpE,GAAG,KACP;CACJ;CAEA,MAAM,SAAmB,CAAC;CAC1B,MAAM,OAAkB,CAAC;CACzB,MAAM,YAAY,MAAc,UAAkB;EAC9C,OAAO,KAAK,QAAQ;EACpB,KAAK,KAAK,UAAU,SAAS,MAAM,EAAE;CACzC;CAEA,IAAI,OAAO,OAAO,SAAS,cAAc,OAAO,KAAK,CAAC,MAAM,cAAc,OAAO,KAAK,CAAC,QAAQ;CAC/F,IAAI,OAAO,WAAW,SAAS,iBAAiB,OAAO,IAAI,GAAG,SAAS;CACvE,IAAI,OAAO,QAAQ,SAAS,OAAO,QAAQ,SAAS;CACpD,KAAK,MAAM,OAAO,OAAO,MAAM;EAC3B,OAAO,KAAK,OAAO,QAAQ,WAAW,OAAO,IAAI;EACjD,KAAK,KAAK,GAAG;CACjB;CAEA,IAAI,OAAO,QAAQ,SAAS,OAAO,QAAQ,SAAS;CACpD,OAAO,CACH,OAAO,KAAK,GAAG,GACf,GAAG,IACP;AACJ;;AAGA,SAAgB,kBAAkB,QAAsB,SAAS,OAAkB;CAC/E,MAAM,QAAmB,CAAC;CAC1B,MAAM,SAAS,MAAc,UAAkB,SAAS,UAAU,MAAM,GAAG,KAAK,aAAa;CAC7F,IAAI,OAAO,OAAO,MAAM,KAAK,MAAM,cAAc,OAAO,KAAK,CAAC,MAAM,cAAc,OAAO,KAAK,CAAC,SAAS,CAAC;CACzG,IAAI,OAAO,WAAW,MAAM,KAAK,MAAM,iBAAiB,OAAO,IAAI,GAAG,IAAI,CAAC;CAC3E,IAAI,OAAO,QAAQ,MAAM,KAAK,MAAM,OAAO,QAAQ,IAAI,CAAC;CACxD,MAAM,KAAK,GAAG,OAAO,IAAI;CACzB,IAAI,OAAO,QAAQ,MAAM,KAAK,MAAM,OAAO,QAAQ,IAAI,CAAC;CACxD,OAAO;AACX;;AAGA,SAAgB,iBAAiB,MAAoB;CACjD,MAAM,OAAO,OAAe,QAAQ,MAAM,OAAO,KAAK,CAAC,CAAC,SAAS,OAAO,GAAG;CAG3E,OAAO,IAAI,GAFI,KAAK,YAAY,EAAE,GAAG,IAAI,KAAK,SAAS,IAAI,CAAC,EAAE,GAAG,IAAI,KAAK,QAAQ,CAAC,IAEpE,GAAG,GADF,IAAI,KAAK,SAAS,CAAC,EAAE,GAAG,IAAI,KAAK,WAAW,CAAC,EAAE,GAAG,IAAI,KAAK,WAAW,CAAC,IAChE,GAAG,IAAI,KAAK,gBAAgB,GAAG,CAAC,EAAE;AAC7D;;AAGA,SAAgB,oBAAoB,QAAiE;CACjG,IAAI,OAAO,WAAW,OAAO,OAAO,UAAU;CAC9C,MAAM,SAAS,QAAQ,IAAI;CAC3B,IAAI,WAAW,KAAA,GACX,OAAO;EACH;EACA;EACA;EACA;EACA;CACJ,CAAC,CAAC,SAAS,MAAM;CAGrB,OAAO,QAAQ,OAAO,KAAK,KACtB,CAAC,QAAQ,IAAI,YACb,CAAC,QAAQ,IAAI,uBACb,QAAQ,IAAI,SAAS;AAC9B"}