@kikiutils/shared 18.2.0 → 19.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,5 +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,5 +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

@@ -0,0 +1,25 @@
+import { BinaryInput } from "./types/index.js";
+/**
+ * Detects a lowercase MIME type from binary content rather than its name or declared type.
+ *
+ * @remarks
+ * Requires the optional `file-type` peer dependency. Only formats supported by its binary detection
+ * are recognized; this is not a general text-file detector or a guarantee that a file is safe.
+ * Blob and File inputs are read through the detector's tokenizer instead of being fully buffered up front.
+ * The amount of content inspected depends on its format; this does not impose a fixed read limit.
+ * Detection and input-reading errors propagate to the caller.
+ *
+ * @param input - The binary content to inspect.
+ *
+ * @returns The detected lowercase MIME type, or `undefined` when the content is not recognized.
+ *
+ * @example
+ *
+ * ```ts
+ * import { getFileMimeType } from '@kikiutils/shared/file';
+ *
+ * const mimeType = await getFileMimeType(file);
+ * ```
+ */
+export declare function getFileMimeType(input: BinaryInput): Promise<string | undefined>;
+//# sourceMappingURL=file.d.ts.map

package/dist/file.d.ts.map

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

package/dist/file.js

@@ -0,0 +1,30 @@
+import { fileTypeFromBlob, fileTypeFromBuffer } from "file-type";
+// src/file.ts
+/**
+* Detects a lowercase MIME type from binary content rather than its name or declared type.
+*
+* @remarks
+* Requires the optional `file-type` peer dependency. Only formats supported by its binary detection
+* are recognized; this is not a general text-file detector or a guarantee that a file is safe.
+* Blob and File inputs are read through the detector's tokenizer instead of being fully buffered up front.
+* The amount of content inspected depends on its format; this does not impose a fixed read limit.
+* Detection and input-reading errors propagate to the caller.
+*
+* @param input - The binary content to inspect.
+*
+* @returns The detected lowercase MIME type, or `undefined` when the content is not recognized.
+*
+* @example
+*
+* ```ts
+* import { getFileMimeType } from '@kikiutils/shared/file';
+*
+* const mimeType = await getFileMimeType(file);
+* ```
+*/
+async function getFileMimeType(input) {
+	return (input instanceof ArrayBuffer || input instanceof Uint8Array ? await fileTypeFromBuffer(input) : await fileTypeFromBlob(input))?.mime.toLowerCase();
+}
+export { getFileMimeType };
+
+//# sourceMappingURL=file.js.map

package/dist/file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.js","names":[],"sources":["../src/file.ts"],"sourcesContent":["import {\n    fileTypeFromBlob,\n    fileTypeFromBuffer,\n} from 'file-type';\n\nimport type { BinaryInput } from './types';\n\n/**\n * Detects a lowercase MIME type from binary content rather than its name or declared type.\n *\n * @remarks\n * Requires the optional `file-type` peer dependency. Only formats supported by its binary detection\n * are recognized; this is not a general text-file detector or a guarantee that a file is safe.\n * Blob and File inputs are read through the detector's tokenizer instead of being fully buffered up front.\n * The amount of content inspected depends on its format; this does not impose a fixed read limit.\n * Detection and input-reading errors propagate to the caller.\n *\n * @param input - The binary content to inspect.\n *\n * @returns The detected lowercase MIME type, or `undefined` when the content is not recognized.\n *\n * @example\n *\n * ```ts\n * import { getFileMimeType } from '@kikiutils/shared/file';\n *\n * const mimeType = await getFileMimeType(file);\n * ```\n */\nexport async function getFileMimeType(input: BinaryInput) {\n    // The tokenizer only uses size, slice, and arrayBuffer; Node/DOM Blob stream typings differ.\n    const result = input instanceof ArrayBuffer || input instanceof Uint8Array\n        ? await fileTypeFromBuffer(input)\n        : await fileTypeFromBlob(input as Blob);\n\n    return result?.mime.toLowerCase();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA6BA,eAAsB,gBAAgB,OAAoB;CAMtD,QAJe,iBAAiB,eAAe,iBAAiB,aAC1D,MAAM,mBAAmB,KAAK,IAC9B,MAAM,iBAAiB,KAAa,EAAA,EAE3B,KAAK,YAAY;AACpC"}

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"}