@kikiutils/shared 13.5.1 → 13.6.0

package/dist/buffer.d.ts

@@ -1,4 +1,5 @@
-import { Blob as Blob$1, Buffer, File as File$1 } from "node:buffer";
+import { BinaryInput } from "./types/index.js";
+import { Buffer } from "node:buffer";
 
 //#region src/buffer.d.ts
 
@@ -33,7 +34,7 @@ import { Blob as Blob$1, Buffer, File as File$1 } from "node:buffer";
  * console.log(result3.toString()); // 'File content'
  * ```
  */
-declare function toBuffer(input: Blob | Buffer | File | Blob$1 | File$1): Promise<Buffer<ArrayBufferLike>>;
+declare function toBuffer(input: BinaryInput): Promise<Buffer<ArrayBufferLike>>;
 //#endregion
 export { toBuffer };
 //# sourceMappingURL=buffer.d.ts.map

package/dist/buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.d.ts","names":[],"sources":["../src/buffer.ts"],"sourcesContent":[],"mappings":";;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,QAAA,QAAgB,OAAO,SAAS,OAAO,SAAW,SAAQ,QAAA,OAAA"}
+{"version":3,"file":"buffer.d.ts","names":[],"sources":["../src/buffer.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,QAAA,QAAgB,cAAW,QAAA,OAAA"}

package/dist/buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer.js","names":[],"sources":["../src/buffer.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\nimport type {\n    Blob as NodeBlob,\n    File as NodeFile,\n} from 'node:buffer';\n\n/**\n * Converts a Blob, Buffer, or File to a Buffer.\n *\n * This function provides a unified way to convert various binary data types\n * to Node.js Buffer. If the input is already a Buffer, it returns it as-is.\n * For Blob or File inputs, it converts them to Buffer via ArrayBuffer.\n *\n * @param {Blob | Buffer | File} input - The input to convert to Buffer\n *\n * @returns {Promise<Buffer>} A Promise that resolves to a Buffer\n *\n * @example\n * ```typescript\n * import { toBuffer } from '@kikiutils/shared/general';\n *\n * // Convert a Buffer (returns as-is)\n * const buffer = Buffer.from('Hello World');\n * const result1 = await toBuffer(buffer);\n * console.log(result1); // <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>\n *\n * // Convert a Blob\n * const blob = new Blob(['Hello from Blob'], { type: 'text/plain' });\n * const result2 = await toBuffer(blob);\n * console.log(result2.toString()); // 'Hello from Blob'\n *\n * // Convert a File\n * const file = new File(['File content'], 'test.txt', { type: 'text/plain' });\n * const result3 = await toBuffer(file);\n * console.log(result3.toString()); // 'File content'\n * ```\n */\nexport async function toBuffer(input: Blob | Buffer | File | NodeBlob | NodeFile) {\n    if (Buffer.isBuffer(input)) return input;\n    return Buffer.from(await input.arrayBuffer());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,eAAsB,SAAS,OAAmD;AAC9E,KAAI,OAAO,SAAS,MAAM,CAAE,QAAO;AACnC,QAAO,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC"}
+{"version":3,"file":"buffer.js","names":[],"sources":["../src/buffer.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\n\nimport type { BinaryInput } from './types';\n\n/**\n * Converts a Blob, Buffer, or File to a Buffer.\n *\n * This function provides a unified way to convert various binary data types\n * to Node.js Buffer. If the input is already a Buffer, it returns it as-is.\n * For Blob or File inputs, it converts them to Buffer via ArrayBuffer.\n *\n * @param {Blob | Buffer | File} input - The input to convert to Buffer\n *\n * @returns {Promise<Buffer>} A Promise that resolves to a Buffer\n *\n * @example\n * ```typescript\n * import { toBuffer } from '@kikiutils/shared/general';\n *\n * // Convert a Buffer (returns as-is)\n * const buffer = Buffer.from('Hello World');\n * const result1 = await toBuffer(buffer);\n * console.log(result1); // <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>\n *\n * // Convert a Blob\n * const blob = new Blob(['Hello from Blob'], { type: 'text/plain' });\n * const result2 = await toBuffer(blob);\n * console.log(result2.toString()); // 'Hello from Blob'\n *\n * // Convert a File\n * const file = new File(['File content'], 'test.txt', { type: 'text/plain' });\n * const result3 = await toBuffer(file);\n * console.log(result3.toString()); // 'File content'\n * ```\n */\nexport async function toBuffer(input: BinaryInput) {\n    if (Buffer.isBuffer(input)) return input;\n    return Buffer.from(await input.arrayBuffer());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,eAAsB,SAAS,OAAoB;AAC/C,KAAI,OAAO,SAAS,MAAM,CAAE,QAAO;AACnC,QAAO,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"path.d.ts","names":[],"sources":["../../src/classes/path.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"path.d.ts","names":[],"sources":["../../src/classes/path.ts"],"sourcesContent":[],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"precision-number.d.ts","names":[],"sources":["../../src/classes/precision-number.ts"],"sourcesContent":[],"mappings":";;;KAEY,oBAAA,GAAuB,OAAA,CAAQ,QAAQ;;AAAnD,CAAA;;;;;AAkBA;;;;;;;;;;;;AAgGe,cAhGF,eAAA,CAgGE;UAIE;aAUD,CAAA,KAAA,CAAA,EAvGD,oBAuGC,EAAA,aAAA,CAAA,EAAA,MAAA,EAAA,QAAA,CAAA,EArGE,OAAA,CAAQ,QAqGV;GAzFX,MAAA,CAAO,WAAA,EA8FK,IAAA,EAAA,MAAA,CAAA,EAAA,MAAA,GAAA,MAAA;MAKE,KAAA,CAAA,CAAA,EAAA,MAAA;SAII,OAAA,CAAA,KAAA,EAtFR,oBAsFQ,EAAA,aAAA,CAAA,EAAA,MAAA,EAAA,QAAA,CAAA,EApFL,OAAA,CAAQ,QAoFH,CAAA,EAAA,MAAA;eAAoB,CAAA,CAAA,EAAA,IAAA;WAYxB,CAAA,KAAA,EArFE,oBAqFF,CAAA,EAAA,IAAA;QAAoB,CAAA,KAAA,EAhFrB,oBAgFqB,CAAA,EAAA,OAAA;KAI1B,KAAA,EAhFC,oBAgFD,CAAA,EAAA,OAAA;KAIK,CAAA,KAAA,EAhFH,oBAgFG,CAAA,EAAA,OAAA;UAAoB,CAAA,CAAA,EAAA,OAAA;WAQ6B,CAAA,CAAQ,EAAA,OAAA;OAIxD,CAAA,CAAA,EAAA,OAAA;YAAoB,CAAA,CAAA,EAAA,OAAA;EAAA,UAAA,CAAA,CAAA,EAAA,OAAA;;YAhEzB;aAIC;eAIE;;cAUD;eAKC;qBAKE;qBAII,uBAAoB;;iBAYxB,uBAAoB;eAI1B;gBAIK,uBAAoB;;6CAQ6B,OAAA,CAAQ;iBAIxD,uBAAoB"}
+{"version":3,"file":"precision-number.d.ts","names":[],"sources":["../../src/classes/precision-number.ts"],"sourcesContent":[],"mappings":";;;KAEY,oBAAA,GAAuB,OAAA,CAAQ,QAAQ;;AAAnD,CAAA;AAkBA;;;;;;;;;;;;;;;;AA4HuB,cA5HV,eAAA,CA4HU;EAAoB,CAAA,OAAA;EAYxB,WAAA,CAAA,KAAA,CAAA,EAjIJ,oBAiII,EAAA,aAAA,CAAA,EAAA,MAAA,EAAA,QAAA,CAAA,EA/HD,OAAA,CAAQ,QA+HP;EAAoB,CAnHlC,MAAA,CAAO,WAAA,EAmH2B,IAAA,EAAA,MAAA,CAAA,EAAA,MAAA,GAAA,MAAA;EAI1B,IAAA,KAAA,CAAA,CAAA,EAAA,MAAA;EAIK,OAAA,OAAA,CAAA,KAAA,EA1GH,oBA0GG,EAAA,aAAA,CAAA,EAAA,MAAA,EAAA,QAAA,CAAA,EAxGA,OAAA,CAAQ,QAwGR,CAAA,EAAA,MAAA;EAAoB,aAAA,CAAA,CAAA,EAAA,IAAA;EAQ6B,SAAQ,CAAA,KAAA,EArGtD,oBAqGsD,CAAA,EAAA,IAAA;EAIxD,MAAA,CAAA,KAAA,EApGD,oBAoGC,CAAA,EAAA,OAAA;EAAoB,EAAA,CAAA,KAAA,EAhGzB,oBAgGyB,CAAA,EAAA,OAAA;EAAA,GAAA,CAAA,KAAA,EA5FxB,oBA4FwB,CAAA,EAAA,OAAA;;;;;;;YAhEzB;aAIC;eAIE;;cAUD;eAKC;qBAKE;qBAII,uBAAoB;;iBAYxB,uBAAoB;eAI1B;gBAIK,uBAAoB;;6CAQ6B,OAAA,CAAQ;iBAIxD,uBAAoB"}

package/dist/classes/ssh-client.d.ts

@@ -1,5 +1,5 @@
-import { PathLike } from "./path.js";
 import { Nullable } from "../types/index.js";
+import { PathLike } from "./path.js";
 import * as node_ssh0 from "node-ssh";
 import { Config, NodeSSH, SSHExecCommandOptions, SSHGetPutDirectoryOptions, SSHPutFilesOptions } from "node-ssh";
 import { SFTPWrapper, TransferOptions } from "ssh2";

package/dist/classes/ssh-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssh-client.d.ts","names":[],"sources":["../../src/classes/ssh-client.ts"],"sourcesContent":[],"mappings":";;;;;;;cAkBM;;EAAA,SAAA,KAAA,EAAA,CAAA;EAYO,SAAA,KAAS,EAAA,CAAA;EAAA,SAAA,IAAA,EAAA,CAAA;WAM+E,MAAA,EAAA,CAAA;WActF,MAAA,EAAA,CAAA,GAAA;WAIE,KAAA,EAAA,CAAA;WAoB0B,OAAA,EAAA,GAAA;WAAqB,IAAA,EAAA,CAAA;;AAIf,cAhDpC,SAAA,CAgDoC;UAAqB;aAAA,CAAA,IAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,EAAA,IAAA,CAAA,EAAA,MAAA,EAAA,aAAA,CAAA,EA1C+B,MA0C/B;MAa/B,OAAA,CAAA,CAAA,EAzCxB,OAyCwB;SAA2B,CAAA,CAAA,EArCjD,OAqCiD,CAAA,OAAA,CAAA;YAAoB,CAAA,CAAA,EAAA,OAAA;aAAyB,CAAA,OAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAjBpE,qBAiBoE,CAAA,EAjB/C,OAiB+C,CAAA,IAAA,GAjB/C,SAAA,CAAA,sBAiB+C,CAAA;mBAAxE,CAAA,OAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAbU,qBAaV,CAAA,EAb+B,OAa/B,CAAA,IAAA,GAb+B,SAAA,CAAA,sBAa/B,CAAA;QAA2B,EAAA,CAAA,cAAA,EAA3B,QAA2B,EAAA,eAAA,EAAA,QAAA,EAAA,OAAA,CAAA,EAAoB,yBAApB,EAAA,GAA6C,OAA7C,CAAA,OAAA,CAAA;cAAoB,CAAA,cAAA,EAA/C,QAA+C,EAAA,eAAA,EAApB,QAAoB,EAAA,OAAA,CAAA,EAAA,yBAAA,CAAA,EAAyB,OAAzB,CAAA,OAAA,CAAA;SAAyB,CAAA,SAAA,EAU5F,QAV4F,EAAA,UAAA,EAW3F,QAX2F,EAAA,SAAA,CAAA,EAY3F,QAZ2F,CAYlF,WAZkF,CAAA,EAAA,eAAA,CAAA,EAarF,QAbqF,CAa5E,eAb4E,CAAA,CAAA,EAa5D,OAb4D,CAAA,OAAA,CAAA;aAU5F,CAAA,CAAA,EAAA,OAAA;OACC,CAAA,IAAA,EAiBE,QAjBF,CAAA,EAiBU,OAjBV,CAAA,OAAA,CAAA;QACS,EAAA,CAAA,cAAA,EA4BU,QA5BV,EAAA,eAAA,EA4BqC,QA5BrC,EAAA,OAAA,CAAA,EA4ByD,yBA5BzD,EAAA,GA4BkF,OA5BlF,CAAA,OAAA,CAAA;cAAT,CAAA,cAAA,EA4BmB,QA5BnB,EAAA,eAAA,EA4B8C,QA5B9C,EAAA,OAAA,CAAA,EA4BkE,yBA5BlE,CAAA,EA4B2F,OA5B3F,CAAA,OAAA,CAAA;SACe,CAAA,SAAA,EAqChB,QArCgB,EAAA,UAAA,EAsCf,QAtCe,EAAA,SAAA,CAAA,EAuCf,QAvCe,CAuCN,WAvCM,CAAA,EAAA,eAAA,CAAA,EAwCT,QAxCS,CAwCA,eAxCA,CAAA,CAAA,EAwCgB,OAxChB,CAAA,OAAA,CAAA;UAAT,CAAA,KAAA,EAAA;IAAyB,KAAA,EAmDhB,QAnDgB;IAe7B,MAAA,EAoC+B,QApC/B;KAAQ,EAAA,OAAA,CAAA,EAoC+C,kBApC/C,CAAA,EAoCiE,OApCjE,CAAA,OAAA,CAAA;gBAYS,CAAA,KAAA,EAAA,MAAA,OAuCA,qCAvCA,CAAA,EAAA,IAAA"}
+{"version":3,"file":"ssh-client.d.ts","names":[],"sources":["../../src/classes/ssh-client.ts"],"sourcesContent":[],"mappings":";;;;;;;cAkBM;;EAAA,SAAA,KAAA,EAAA,CAAA;EAYO,SAAA,KAAS,EAAA,CAAA;EAM+E,SAAA,IAAA,EAAA,CAAA;EActF,SAAA,MAAA,EAAA,CAAA;EAIE,SAAA,MAAA,EAAA,CAAA,GAAA;EAoB0B,SAAA,KAAA,EAAA,CAAA;EAAqB,SAAA,OAAA,EAAA,GAAA;EAAA,SAAA,IAAA,EAAA,CAAA;CAIf;AAAqB,cAhDzD,SAAA,CAgDyD;EAAA,CAAA,OAAA;EAa/B,WAAA,CAAA,IAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,EAAA,IAAA,CAAA,EAAA,MAAA,EAAA,aAAA,CAAA,EAvD8D,MAuD9D;EAA2B,IAAA,OAAA,CAAA,CAAA,EAzCnD,OAyCmD;EAAoB,OAAA,CAAA,CAAA,EArCrE,OAqCqE,CAAA,OAAA,CAAA;EAAyB,UAAA,CAAA,CAAA,EAAA,OAAA;EAAxE,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAjBI,qBAiBJ,CAAA,EAjByB,OAiBzB,CAAA,IAAA,GAjByB,SAAA,CAAA,sBAiBzB,CAAA;EAA2B,iBAAA,CAAA,OAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAbjB,qBAaiB,CAAA,EAbI,OAaJ,CAAA,IAAA,GAbI,SAAA,CAAA,sBAaJ,CAAA;EAAoB,MAAA,EAAA,CAAA,cAAA,EAA/C,QAA+C,EAAA,eAAA,EAApB,QAAoB,EAAA,OAAA,CAAA,EAAA,yBAAA,EAAA,GAAyB,OAAzB,CAAA,OAAA,CAAA;EAAyB,YAAA,CAAA,cAAA,EAAxE,QAAwE,EAAA,eAAA,EAA7C,QAA6C,EAAA,OAAA,CAAA,EAAzB,yBAAyB,CAAA,EAAA,OAAA,CAAA,OAAA,CAAA;EAU5F,OAAA,CAAA,SAAA,EAAA,QAAA,EAAA,UAAA,EACC,QADD,EAAA,SAAA,CAAA,EAEC,QAFD,CAEU,WAFV,CAAA,EAAA,eAAA,CAAA,EAGO,QAHP,CAGgB,eAHhB,CAAA,CAAA,EAGgC,OAHhC,CAAA,OAAA,CAAA;EACC,WAAA,CAAA,CAAA,EAAA,OAAA;EACS,KAAA,CAAA,IAAA,EAgBP,QAhBO,CAAA,EAgBC,OAhBD,CAAA,OAAA,CAAA;EAAT,MAAA,EAAA,CAAA,cAAA,EA4BmB,QA5BnB,EAAA,eAAA,EA4B8C,QA5B9C,EAAA,OAAA,CAAA,EA4BkE,yBA5BlE,EAAA,GA4B2F,OA5B3F,CAAA,OAAA,CAAA;EACe,YAAA,CAAA,cAAA,EA2BI,QA3BJ,EAAA,eAAA,EA2B+B,QA3B/B,EAAA,OAAA,CAAA,EA2BmD,yBA3BnD,CAAA,EA2B4E,OA3B5E,CAAA,OAAA,CAAA;EAAT,OAAA,CAAA,SAAA,EAqCP,QArCO,EAAA,UAAA,EAsCN,QAtCM,EAAA,SAAA,CAAA,EAuCN,QAvCM,CAuCG,WAvCH,CAAA,EAAA,eAAA,CAAA,EAwCA,QAxCA,CAwCS,eAxCT,CAAA,CAAA,EAwCyB,OAxCzB,CAAA,OAAA,CAAA;EAAyB,QAAA,CAAA,KAAA,EAAA;IAe7B,KAAA,EAoCa,QApCb;IAAQ,MAAA,EAoCuB,QApCvB;EAYS,CAAA,EAAA,EAAA,OAAA,CAAA,EAwBsC,kBAxBtC,CAAA,EAwBwD,OAxBxD,CAAA,OAAA,CAAA;EAA2B,cAAA,CAAA,KAAA,EAAA,MAAA,OAuC3B,qCAvC2B,CAAA,EAAA,IAAA"}

package/dist/clipboard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clipboard.d.ts","names":[],"sources":["../src/clipboard.ts"],"sourcesContent":[],"mappings":";KAAK,UAAA;EAAA,KAAA,EAAA,OAAU;EAgCO,EAAA,EAAA,KAAA;CAAmB,GAAA;MAAO,IAAA;;;;;AA8ChD;;;;;;;;;;;;;;;;;;;;;;;;;iBA9CsB,mBAAA,OAA0B,gBAAgB,uBAAuB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CzE,mBAAA,gBAAmC,QAAQ"}
+{"version":3,"file":"clipboard.d.ts","names":[],"sources":["../src/clipboard.ts"],"sourcesContent":[],"mappings":";KAAK,UAAA;EAAA,KAAA,EAAA,OAAU;EAgCO,EAAA,EAAA,KAAA;CAA0B,GAAA;EAAgB,EAAA,EAAA,IAAA;CAA+B;;;AA8C/F;;;;;;;;;;;;;;;;;;;;;;;;;;iBA9CsB,mBAAA,OAA0B,gBAAgB,uBAAuB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CzE,mBAAA,gBAAmC,QAAQ"}

package/dist/crypto-hash.d.ts

@@ -3,15 +3,15 @@ import { BinaryLike, BinaryToTextEncoding } from "node:crypto";
 //#region src/crypto-hash.d.ts
 
 declare function cryptoMd5(data: BinaryLike, outputEncoding?: BinaryToTextEncoding): string;
-declare function cryptoMd5ToBuffer(data: BinaryLike): Buffer<ArrayBufferLike>;
+declare function cryptoMd5ToBuffer(data: BinaryLike): NonSharedBuffer;
 declare function cryptoSha3224(data: BinaryLike, outputEncoding?: BinaryToTextEncoding): string;
-declare function cryptoSha3224ToBuffer(data: BinaryLike): Buffer<ArrayBufferLike>;
+declare function cryptoSha3224ToBuffer(data: BinaryLike): NonSharedBuffer;
 declare function cryptoSha3256(data: BinaryLike, outputEncoding?: BinaryToTextEncoding): string;
-declare function cryptoSha3256ToBuffer(data: BinaryLike): Buffer<ArrayBufferLike>;
+declare function cryptoSha3256ToBuffer(data: BinaryLike): NonSharedBuffer;
 declare function cryptoSha3384(data: BinaryLike, outputEncoding?: BinaryToTextEncoding): string;
-declare function cryptoSha3384ToBuffer(data: BinaryLike): Buffer<ArrayBufferLike>;
+declare function cryptoSha3384ToBuffer(data: BinaryLike): NonSharedBuffer;
 declare function cryptoSha3512(data: BinaryLike, outputEncoding?: BinaryToTextEncoding): string;
-declare function cryptoSha3512ToBuffer(data: BinaryLike): Buffer<ArrayBufferLike>;
+declare function cryptoSha3512ToBuffer(data: BinaryLike): NonSharedBuffer;
 //#endregion
 export { cryptoMd5, cryptoMd5ToBuffer, cryptoSha3224, cryptoSha3224ToBuffer, cryptoSha3256, cryptoSha3256ToBuffer, cryptoSha3384, cryptoSha3384ToBuffer, cryptoSha3512, cryptoSha3512ToBuffer };
 //# 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"],"sourcesContent":[],"mappings":";;;;AA8BoC,iBARpB,SAAA,CAQoB,IAAA,EARJ,UAQI,EAAA,cAAA,CAAA,EARwB,oBAQxB,CAAA,EAAA,MAAA;AAA4B,iBAJhD,iBAAA,CAIgD,IAAA,EAJxB,UAIwB,CAAA,EAJd,MAIc,CAJd,eAIc,CAAA;AAA4B,iBAA5E,aAAA,CAA4E,IAAA,EAAxD,UAAwD,EAAA,cAAA,CAAA,EAA5B,oBAA4B,CAAA,EAAA,MAAA;AAI5E,iBAAA,qBAAA,CAAqB,IAAA,EAAO,UAAP,CAAA,EAAiB,MAAjB,CAAiB,eAAjB,CAAA;AAAA,iBAIrB,aAAA,CAJqB,IAAA,EAID,UAJC,EAAA,cAAA,CAAA,EAI2B,oBAJ3B,CAAA,EAAA,MAAA;AAAO,iBAQ5B,qBAAA,CAR4B,IAAA,EAQA,UARA,CAAA,EAQU,MARV,CAQU,eARV,CAAA;AAAU,iBAYtC,aAAA,CAZsC,IAAA,EAYlB,UAZkB,EAAA,cAAA,CAAA,EAYU,oBAZV,CAAA,EAAA,MAAA;AAAA,iBAgBtC,qBAAA,CAhBsC,IAAA,EAgBV,UAhBU,CAAA,EAgBA,MAhBA,CAgBA,eAhBA,CAAA;AAAA,iBAoBtC,aAAA,CApBsC,IAAA,EAoBlB,UApBkB,EAAA,cAAA,CAAA,EAoBU,oBApBV,CAAA,EAAA,MAAA;AAItC,iBAoBA,qBAAA,CApBa,IAAA,EAoBe,UApBf,CAAA,EAoByB,MApBzB,CAoByB,eApBzB,CAAA"}
+{"version":3,"file":"crypto-hash.d.ts","names":[],"sources":["../src/crypto-hash.ts"],"sourcesContent":[],"mappings":";;;;iBAsBgB,SAAA,OAAgB,6BAA4B;iBAI5C,iBAAA,OAAwB,aAAU;iBAIlC,aAAA,OAAoB,6BAA4B;iBAIhD,qBAAA,OAA4B,aAAU;iBAItC,aAAA,OAAoB,6BAA4B;iBAIhD,qBAAA,OAA4B,aAAU;iBAItC,aAAA,OAAoB,6BAA4B;iBAIhD,qBAAA,OAA4B,aAAU;iBAItC,aAAA,OAAoB,6BAA4B;iBAIhD,qBAAA,OAA4B,aAAU"}

package/dist/crypto-hash.js

@@ -1,6 +1,21 @@
 import { createHash } from "node:crypto";
 
 //#region src/crypto-hash.ts
+/**
+* This file provides a set of functions for creating hash digests using different algorithms and bit lengths.
+* It includes functions for generating SHA-3 hash digests with bit lengths of 224, 256, 384, and 512,
+* as well as a function for generating MD5 hash digests.
+*
+* These functions use the Node.js crypto module to generate the hashes.
+* Can only be used in Node.js/Deno/Bun runtimes.
+*
+* @example
+* ```typescript
+* import { cryptoSha3256 } from '@kikiutils/shared/crypto-hash';
+*
+* console.log(cryptoSha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80
+* ```
+*/
 function cryptoMd5(data, outputEncoding = "hex") {
 	return createHash("md5").update(data).digest(outputEncoding);
 }

package/dist/crypto-hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"crypto-hash.js","names":[],"sources":["../src/crypto-hash.ts"],"sourcesContent":["/**\n * This file provides a set of functions for creating hash digests using different algorithms and bit lengths.\n * It includes functions for generating SHA-3 hash digests with bit lengths of 224, 256, 384, and 512,\n * as well as a function for generating MD5 hash digests.\n *\n * These functions use the Node.js crypto module to generate the hashes.\n * Can only be used in Node.js/Deno/Bun runtimes.\n *\n * @example\n * ```typescript\n * import { cryptoSha3256 } from '@kikiutils/shared/crypto-hash';\n *\n * console.log(cryptoSha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80\n * ```\n */\n\nimport { createHash } from 'node:crypto';\nimport type {\n    BinaryLike,\n    BinaryToTextEncoding,\n} from 'node:crypto';\n\nexport function cryptoMd5(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('md5').update(data).digest(outputEncoding);\n}\n\nexport function cryptoMd5ToBuffer(data: BinaryLike) {\n    return createHash('md5').update(data).digest();\n}\n\nexport function cryptoSha3224(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('sha3-224').update(data).digest(outputEncoding);\n}\n\nexport function cryptoSha3224ToBuffer(data: BinaryLike) {\n    return createHash('sha3-224').update(data).digest();\n}\n\nexport function cryptoSha3256(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('sha3-256').update(data).digest(outputEncoding);\n}\n\nexport function cryptoSha3256ToBuffer(data: BinaryLike) {\n    return createHash('sha3-256').update(data).digest();\n}\n\nexport function cryptoSha3384(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('sha3-384').update(data).digest(outputEncoding);\n}\n\nexport function cryptoSha3384ToBuffer(data: BinaryLike) {\n    return createHash('sha3-384').update(data).digest();\n}\n\nexport function cryptoSha3512(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('sha3-512').update(data).digest(outputEncoding);\n}\n\nexport function cryptoSha3512ToBuffer(data: BinaryLike) {\n    return createHash('sha3-512').update(data).digest();\n}\n"],"mappings":";;;AAsBA,SAAgB,UAAU,MAAkB,iBAAuC,OAAO;AACtF,QAAO,WAAW,MAAM,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGhE,SAAgB,kBAAkB,MAAkB;AAChD,QAAO,WAAW,MAAM,CAAC,OAAO,KAAK,CAAC,QAAQ;;AAGlD,SAAgB,cAAc,MAAkB,iBAAuC,OAAO;AAC1F,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGrE,SAAgB,sBAAsB,MAAkB;AACpD,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,QAAQ;;AAGvD,SAAgB,cAAc,MAAkB,iBAAuC,OAAO;AAC1F,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGrE,SAAgB,sBAAsB,MAAkB;AACpD,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,QAAQ;;AAGvD,SAAgB,cAAc,MAAkB,iBAAuC,OAAO;AAC1F,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGrE,SAAgB,sBAAsB,MAAkB;AACpD,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,QAAQ;;AAGvD,SAAgB,cAAc,MAAkB,iBAAuC,OAAO;AAC1F,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGrE,SAAgB,sBAAsB,MAAkB;AACpD,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,QAAQ"}
+{"version":3,"file":"crypto-hash.js","names":[],"sources":["../src/crypto-hash.ts"],"sourcesContent":["/**\n * This file provides a set of functions for creating hash digests using different algorithms and bit lengths.\n * It includes functions for generating SHA-3 hash digests with bit lengths of 224, 256, 384, and 512,\n * as well as a function for generating MD5 hash digests.\n *\n * These functions use the Node.js crypto module to generate the hashes.\n * Can only be used in Node.js/Deno/Bun runtimes.\n *\n * @example\n * ```typescript\n * import { cryptoSha3256 } from '@kikiutils/shared/crypto-hash';\n *\n * console.log(cryptoSha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80\n * ```\n */\n\nimport { createHash } from 'node:crypto';\nimport type {\n    BinaryLike,\n    BinaryToTextEncoding,\n} from 'node:crypto';\n\nexport function cryptoMd5(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('md5').update(data).digest(outputEncoding);\n}\n\nexport function cryptoMd5ToBuffer(data: BinaryLike) {\n    return createHash('md5').update(data).digest();\n}\n\nexport function cryptoSha3224(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('sha3-224').update(data).digest(outputEncoding);\n}\n\nexport function cryptoSha3224ToBuffer(data: BinaryLike) {\n    return createHash('sha3-224').update(data).digest();\n}\n\nexport function cryptoSha3256(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('sha3-256').update(data).digest(outputEncoding);\n}\n\nexport function cryptoSha3256ToBuffer(data: BinaryLike) {\n    return createHash('sha3-256').update(data).digest();\n}\n\nexport function cryptoSha3384(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('sha3-384').update(data).digest(outputEncoding);\n}\n\nexport function cryptoSha3384ToBuffer(data: BinaryLike) {\n    return createHash('sha3-384').update(data).digest();\n}\n\nexport function cryptoSha3512(data: BinaryLike, outputEncoding: BinaryToTextEncoding = 'hex') {\n    return createHash('sha3-512').update(data).digest(outputEncoding);\n}\n\nexport function cryptoSha3512ToBuffer(data: BinaryLike) {\n    return createHash('sha3-512').update(data).digest();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAsBA,SAAgB,UAAU,MAAkB,iBAAuC,OAAO;AACtF,QAAO,WAAW,MAAM,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGhE,SAAgB,kBAAkB,MAAkB;AAChD,QAAO,WAAW,MAAM,CAAC,OAAO,KAAK,CAAC,QAAQ;;AAGlD,SAAgB,cAAc,MAAkB,iBAAuC,OAAO;AAC1F,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGrE,SAAgB,sBAAsB,MAAkB;AACpD,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,QAAQ;;AAGvD,SAAgB,cAAc,MAAkB,iBAAuC,OAAO;AAC1F,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGrE,SAAgB,sBAAsB,MAAkB;AACpD,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,QAAQ;;AAGvD,SAAgB,cAAc,MAAkB,iBAAuC,OAAO;AAC1F,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGrE,SAAgB,sBAAsB,MAAkB;AACpD,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,QAAQ;;AAGvD,SAAgB,cAAc,MAAkB,iBAAuC,OAAO;AAC1F,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,OAAO,eAAe;;AAGrE,SAAgB,sBAAsB,MAAkB;AACpD,QAAO,WAAW,WAAW,CAAC,OAAO,KAAK,CAAC,QAAQ"}

package/dist/datetime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"datetime.d.ts","names":[],"sources":["../src/datetime.ts"],"sourcesContent":[],"mappings":";;;KAkBY,aAAA;;AAAZ;AA6BA;;;;;;AA+BA;;;;;;;;AAyEA;;;;;;;;;;;iBAxGgB,UAAA,OAAiB,QAAQ,uCAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BvF,oBAAA,OACN,YACA;;iBAGa;;;;;;;;;;;;;;;;;;;;;iBAoEP,wBAAA,uBAA+C"}
+{"version":3,"file":"datetime.d.ts","names":[],"sources":["../src/datetime.ts"],"sourcesContent":[],"mappings":";;;KAkBY,aAAA;;AAAZ;AA6BA;;;;;AA+BA;;;;;;;AAyEA;;;;;;;;;;;;;iBAxGgB,UAAA,OAAiB,QAAQ,uCAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BvF,oBAAA,OACN,YACA;;iBAGa;;;;;;;;;;;;;;;;;;;;;iBAoEP,wBAAA,uBAA+C"}

package/dist/enum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enum.d.ts","names":[],"sources":["../src/enum.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;;AA2BA;;;;;;;;AAkDA;;;;;;AAAuF,iBA7EvE,mBA6EuE,CAAA,UA7EzC,MA6EyC,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,CAAA,UAAA,EA7ER,CA6EQ,CAAA,EA7EJ,OA6EI,CA7EI,CA6EJ,CAAA,MA7EY,CA6EZ,CAAA,EAAA,MAAA,CAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;iBAlDvE,8BAA8B,iCAAiC,IAAI,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDnF,wBAAwB,iCAAiC,KAAK,QAAQ"}
+{"version":3,"file":"enum.d.ts","names":[],"sources":["../src/enum.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;AA2BA;;;;;;;AAkDA;;;;;;;;iBA7EgB,8BAA8B,iCAAiC,IAAI,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;iBA2BnF,8BAA8B,iCAAiC,IAAI,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDnF,wBAAwB,iCAAiC,KAAK,QAAQ"}

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

@@ -1 +1 @@
-{"version":3,"file":"event-awaiter.d.ts","names":[],"sources":["../src/event-awaiter.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;;;;;;;;AAiIoE,cAjIvD,YAiIuD,CAAA,CAAA,CAAA,CAAA;UAAA;EAAA;;;;;;;;8BAtHpC;;;;;;;;;;qBAiBV;;;;;;;;;;;;;;;;;;;;;;;;+EA4B2D,cAAW,QAAA;;;;;;;;;;;0DA2DhC,cAAW,QAAA;;;;;;;;;;;uDAcd,cAAW,QAAA"}
+{"version":3,"file":"event-awaiter.d.ts","names":[],"sources":["../src/event-awaiter.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;;;;;;;;AAiIoE,cAjIvD,YAiIuD,CAAA,CAAA,CAAA,CAAA;EAAA,CAAA,OAAA;;;;;;;;;8BAtHpC;;;;;;;;;;qBAiBV;;;;;;;;;;;;;;;;;;;;;;;;+EA4B2D,cAAW,QAAA;;;;;;;;;;;0DA2DhC,cAAW,QAAA;;;;;;;;;;;uDAcd,cAAW,QAAA"}

package/dist/general.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"general.d.ts","names":[],"sources":["../src/general.ts"],"sourcesContent":[],"mappings":";;AA2BA;;;;;;AACA;;;;;;;;;;;;;;;;;;iBADgB,4BAA4B,IAAI,MAAM;iBACtC,+BAA+B,IAAI,mBAAmB,IAAI,IAAI,YAAY"}
+{"version":3,"file":"general.d.ts","names":[],"sources":["../src/general.ts"],"sourcesContent":[],"mappings":";;AA2BA;;;;;AACA;;;;;;;;;;;;;;;;;;;iBADgB,4BAA4B,IAAI,MAAM;iBACtC,+BAA+B,IAAI,mBAAmB,IAAI,IAAI,YAAY"}

package/dist/hash.js

@@ -1,7 +1,20 @@
-import { sha3_224, sha3_256, sha3_384, sha3_512 } from "@noble/hashes/sha3";
-import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
+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
+/**
+* This file provides a set of functions for creating SHA-3 hash digests
+* using different bit lengths (224, 256, 384, 512).
+* These functions use the [@noble/hashes](https://github.com/paulmillr/noble-hashes) library to generate the hashes.
+* Can be used in the browser, mainly for Nuxt/Vue and other frameworks compiled and executed in the browser.
+*
+* @example
+* ```typescript
+* import { sha3256 } from '@kikiutils/shared/hash';
+*
+* console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80
+* ```
+*/
 function sha3224(data) {
 	return bytesToHex(sha3_224(typeof data === "string" ? utf8ToBytes(data) : data));
 }

package/dist/hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"hash.js","names":[],"sources":["../src/hash.ts"],"sourcesContent":["/**\n * This file provides a set of functions for creating SHA-3 hash digests\n * using different bit lengths (224, 256, 384, 512).\n * These functions use the [@noble/hashes](https://github.com/paulmillr/noble-hashes) library to generate the hashes.\n * Can be used in the browser, mainly for Nuxt/Vue and other frameworks compiled and executed in the browser.\n *\n * @example\n * ```typescript\n * import { sha3256 } from '@kikiutils/shared/hash';\n *\n * console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80\n * ```\n */\n\nimport {\n    sha3_224,\n    sha3_256,\n    sha3_384,\n    sha3_512,\n} from '@noble/hashes/sha3';\nimport {\n    bytesToHex,\n    utf8ToBytes,\n} from '@noble/hashes/utils';\n\nexport function sha3224(data: string | Uint8Array) {\n    return bytesToHex(sha3_224(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n\nexport function sha3256(data: string | Uint8Array) {\n    return bytesToHex(sha3_256(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n\nexport function sha3384(data: string | Uint8Array) {\n    return bytesToHex(sha3_384(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n\nexport function sha3512(data: string | Uint8Array) {\n    return bytesToHex(sha3_512(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n"],"mappings":";;;;AAyBA,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC;;AAGpF,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC;;AAGpF,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC;;AAGpF,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC"}
+{"version":3,"file":"hash.js","names":[],"sources":["../src/hash.ts"],"sourcesContent":["/**\n * This file provides a set of functions for creating SHA-3 hash digests\n * using different bit lengths (224, 256, 384, 512).\n * These functions use the [@noble/hashes](https://github.com/paulmillr/noble-hashes) library to generate the hashes.\n * Can be used in the browser, mainly for Nuxt/Vue and other frameworks compiled and executed in the browser.\n *\n * @example\n * ```typescript\n * import { sha3256 } from '@kikiutils/shared/hash';\n *\n * console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80\n * ```\n */\n\nimport {\n    sha3_224,\n    sha3_256,\n    sha3_384,\n    sha3_512,\n} from '@noble/hashes/sha3.js';\nimport {\n    bytesToHex,\n    utf8ToBytes,\n} from '@noble/hashes/utils.js';\n\nexport function sha3224(data: string | Uint8Array) {\n    return bytesToHex(sha3_224(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n\nexport function sha3256(data: string | Uint8Array) {\n    return bytesToHex(sha3_256(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n\nexport function sha3384(data: string | Uint8Array) {\n    return bytesToHex(sha3_384(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n\nexport function sha3512(data: string | Uint8Array) {\n    return bytesToHex(sha3_512(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyBA,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC;;AAGpF,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC;;AAGpF,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC;;AAGpF,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC"}

package/dist/math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.ts","names":[],"sources":["../src/math.ts"],"sourcesContent":[],"mappings":";;;KAEK,eAAA,GAAkB,OAAA,CAAQ;;AAFM,CAAA;AAOrC;AAsCA;;AACe,UAvCE,yBAAA,CAuCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBADC,kBAAA,YACD,8BACE,2BACH"}
+{"version":3,"file":"math.d.ts","names":[],"sources":["../src/math.ts"],"sourcesContent":[],"mappings":";;;KAEK,eAAA,GAAkB,OAAA,CAAQ;;AAFM,CAAA;AAOrC;AAsCA;;AAEiB,UAxCA,yBAAA,CAwCA;EACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHE,kBAAA,YACD,8BACE,2BACH"}

package/dist/object.js

@@ -25,8 +25,8 @@
 function stringifyObjectDeterministically(input, kvSeparator = "=", pairSeparator = "&") {
 	const entries = [];
 	function walk(object, path = []) {
-		if (Array.isArray(object)) object.forEach((value, index) => {
-			walk(value, [...path, index.toString()]);
+		if (Array.isArray(object)) object.forEach((value, i) => {
+			walk(value, [...path, i.toString()]);
 		});
 		else if (object !== null && typeof object === "object" && Object.prototype.toString.call(object) === "[object Object]") Object.keys(object).sort().forEach((key) => {
 			walk(object[key], [...path, key]);

package/dist/object.js.map

@@ -1 +1 @@
-{"version":3,"file":"object.js","names":["entries: string[]"],"sources":["../src/object.ts"],"sourcesContent":["/**\n * Serializes a nested object into a deterministic, flat string format.\n *\n * This function recursively traverses the input object (including nested objects and arrays),\n * flattens it into key paths using dot notation (e.g. \"a.b.0.c\"), sorts all keys,\n * and joins each key-value pair into a string with customizable separators.\n *\n * It is designed for use cases such as signature generation, cache key construction,\n * or any context requiring consistent and predictable object serialization.\n *\n * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays\n * @param {string} kvSeparator - The string used to separate each key from its value (default: '=')\n * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&')\n * @returns {string} A deterministic string representation of the input object\n *\n * @example\n * ```typescript\n * import { stringifyObjectDeterministically } from '@kikiutils/shared/object';\n *\n * console.log(stringifyObjectDeterministically({ b: 2, a: { x: 1, y: [3, 4] } })); // a.x=1&a.y.0=3&a.y.1=4&b=2\n * console.log(stringifyObjectDeterministically({ foo: 'bar' }, ':', '|')); // foo:bar\n * ```\n */\nexport function stringifyObjectDeterministically(\n    input: Record<string, any>,\n    kvSeparator: string = '=',\n    pairSeparator: string = '&',\n) {\n    const entries: string[] = [];\n\n    function walk(object: any, path: string[] = []) {\n        if (Array.isArray(object)) {\n            object.forEach((value, index) => {\n                walk(\n                    value,\n                    [\n                        ...path,\n                        index.toString(),\n                    ],\n                );\n            });\n        } else if (\n            object !== null\n            && typeof object === 'object'\n            && Object.prototype.toString.call(object) === '[object Object]'\n        ) {\n            Object.keys(object).sort().forEach((key) => {\n                walk(\n                    object[key],\n                    [\n                        ...path,\n                        key,\n                    ],\n                );\n            });\n        } else entries.push(`${path.join('.')}${kvSeparator}${String(object)}`);\n    }\n\n    walk(input);\n    return entries.sort().join(pairSeparator);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,iCACZ,OACA,cAAsB,KACtB,gBAAwB,KAC1B;CACE,MAAMA,UAAoB,EAAE;CAE5B,SAAS,KAAK,QAAa,OAAiB,EAAE,EAAE;AAC5C,MAAI,MAAM,QAAQ,OAAO,CACrB,QAAO,SAAS,OAAO,UAAU;AAC7B,QACI,OACA,CACI,GAAG,MACH,MAAM,UAAU,CACnB,CACJ;IACH;WAEF,WAAW,QACR,OAAO,WAAW,YAClB,OAAO,UAAU,SAAS,KAAK,OAAO,KAAK,kBAE9C,QAAO,KAAK,OAAO,CAAC,MAAM,CAAC,SAAS,QAAQ;AACxC,QACI,OAAO,MACP,CACI,GAAG,MACH,IACH,CACJ;IACH;MACC,SAAQ,KAAK,GAAG,KAAK,KAAK,IAAI,GAAG,cAAc,OAAO,OAAO,GAAG;;AAG3E,MAAK,MAAM;AACX,QAAO,QAAQ,MAAM,CAAC,KAAK,cAAc"}
+{"version":3,"file":"object.js","names":["entries: string[]"],"sources":["../src/object.ts"],"sourcesContent":["/**\n * Serializes a nested object into a deterministic, flat string format.\n *\n * This function recursively traverses the input object (including nested objects and arrays),\n * flattens it into key paths using dot notation (e.g. \"a.b.0.c\"), sorts all keys,\n * and joins each key-value pair into a string with customizable separators.\n *\n * It is designed for use cases such as signature generation, cache key construction,\n * or any context requiring consistent and predictable object serialization.\n *\n * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays\n * @param {string} kvSeparator - The string used to separate each key from its value (default: '=')\n * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&')\n * @returns {string} A deterministic string representation of the input object\n *\n * @example\n * ```typescript\n * import { stringifyObjectDeterministically } from '@kikiutils/shared/object';\n *\n * console.log(stringifyObjectDeterministically({ b: 2, a: { x: 1, y: [3, 4] } })); // a.x=1&a.y.0=3&a.y.1=4&b=2\n * console.log(stringifyObjectDeterministically({ foo: 'bar' }, ':', '|')); // foo:bar\n * ```\n */\nexport function stringifyObjectDeterministically(\n    input: Record<string, any>,\n    kvSeparator: string = '=',\n    pairSeparator: string = '&',\n) {\n    const entries: string[] = [];\n\n    function walk(object: any, path: string[] = []) {\n        if (Array.isArray(object)) {\n            object.forEach((value, i) => {\n                walk(\n                    value,\n                    [\n                        ...path,\n                        i.toString(),\n                    ],\n                );\n            });\n        } else if (\n            object !== null\n            && typeof object === 'object'\n            && Object.prototype.toString.call(object) === '[object Object]'\n        ) {\n            Object.keys(object).sort().forEach((key) => {\n                walk(\n                    object[key],\n                    [\n                        ...path,\n                        key,\n                    ],\n                );\n            });\n        } else entries.push(`${path.join('.')}${kvSeparator}${String(object)}`);\n    }\n\n    walk(input);\n    return entries.sort().join(pairSeparator);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,iCACZ,OACA,cAAsB,KACtB,gBAAwB,KAC1B;CACE,MAAMA,UAAoB,EAAE;CAE5B,SAAS,KAAK,QAAa,OAAiB,EAAE,EAAE;AAC5C,MAAI,MAAM,QAAQ,OAAO,CACrB,QAAO,SAAS,OAAO,MAAM;AACzB,QACI,OACA,CACI,GAAG,MACH,EAAE,UAAU,CACf,CACJ;IACH;WAEF,WAAW,QACR,OAAO,WAAW,YAClB,OAAO,UAAU,SAAS,KAAK,OAAO,KAAK,kBAE9C,QAAO,KAAK,OAAO,CAAC,MAAM,CAAC,SAAS,QAAQ;AACxC,QACI,OAAO,MACP,CACI,GAAG,MACH,IACH,CACJ;IACH;MACC,SAAQ,KAAK,GAAG,KAAK,KAAK,IAAI,GAAG,cAAc,OAAO,OAAO,GAAG;;AAG3E,MAAK,MAAM;AACX,QAAO,QAAQ,MAAM,CAAC,KAAK,cAAc"}

package/dist/random.js

@@ -22,8 +22,7 @@
 function generateWithNestedRandomLength(generator, minMin, minMax, maxMin, maxMax) {
 	const random = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
 	const innerMin = random(minMin, minMax);
-	const finalLength = random(Math.max(innerMin, maxMin), maxMax);
-	return generator(finalLength);
+	return generator(random(Math.max(innerMin, maxMin), maxMax));
 }
 
 //#endregion

package/dist/random.js.map

@@ -1 +1 @@
-{"version":3,"file":"random.js","names":[],"sources":["../src/random.ts"],"sourcesContent":["/**\n * Generates a value using a provided generator function, where the input length\n * is determined by two levels of nested random ranges:\n *\n * 1. First, a random number (`innerMin`) is chosen between `minMin` and `minMax`.\n * 2. Then, a final length is chosen between `Math.max(innerMin, maxMin)` and `maxMax`.\n * 3. The generator is called with the final length and its result is returned.\n *\n * This function supports any return type by using a generic type parameter.\n *\n * @template T - The return type of the generator function\n *\n * @param {(length: number) => T} generator - A function that accepts a length and returns a value of type T\n * @param {number} minMin - Lower bound of the first random range\n * @param {number} minMax - Upper bound of the first random range\n * @param {number} maxMin - Lower bound of the second random range\n * @param {number} maxMax - Upper bound of the second random range\n *\n * @returns {T} The result of the generator function using the computed final length\n */\nexport function generateWithNestedRandomLength<T = string>(\n    generator: (length: number) => T,\n    minMin: number,\n    minMax: number,\n    maxMin: number,\n    maxMax: number,\n) {\n    const random = (min: number, max: number) => Math.floor(Math.random() * (max - min + 1)) + min;\n    const innerMin = random(minMin, minMax);\n    const finalLength = random(Math.max(innerMin, maxMin), maxMax);\n    return generator(finalLength);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,+BACZ,WACA,QACA,QACA,QACA,QACF;CACE,MAAM,UAAU,KAAa,QAAgB,KAAK,MAAM,KAAK,QAAQ,IAAI,MAAM,MAAM,GAAG,GAAG;CAC3F,MAAM,WAAW,OAAO,QAAQ,OAAO;CACvC,MAAM,cAAc,OAAO,KAAK,IAAI,UAAU,OAAO,EAAE,OAAO;AAC9D,QAAO,UAAU,YAAY"}
+{"version":3,"file":"random.js","names":[],"sources":["../src/random.ts"],"sourcesContent":["/**\n * Generates a value using a provided generator function, where the input length\n * is determined by two levels of nested random ranges:\n *\n * 1. First, a random number (`innerMin`) is chosen between `minMin` and `minMax`.\n * 2. Then, a final length is chosen between `Math.max(innerMin, maxMin)` and `maxMax`.\n * 3. The generator is called with the final length and its result is returned.\n *\n * This function supports any return type by using a generic type parameter.\n *\n * @template T - The return type of the generator function\n *\n * @param {(length: number) => T} generator - A function that accepts a length and returns a value of type T\n * @param {number} minMin - Lower bound of the first random range\n * @param {number} minMax - Upper bound of the first random range\n * @param {number} maxMin - Lower bound of the second random range\n * @param {number} maxMax - Upper bound of the second random range\n *\n * @returns {T} The result of the generator function using the computed final length\n */\nexport function generateWithNestedRandomLength<T = string>(\n    generator: (length: number) => T,\n    minMin: number,\n    minMax: number,\n    maxMin: number,\n    maxMax: number,\n) {\n    const random = (min: number, max: number) => Math.floor(Math.random() * (max - min + 1)) + min;\n    const innerMin = random(minMin, minMax);\n    const finalLength = random(Math.max(innerMin, maxMin), maxMax);\n    return generator(finalLength);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,+BACZ,WACA,QACA,QACA,QACA,QACF;CACE,MAAM,UAAU,KAAa,QAAgB,KAAK,MAAM,KAAK,QAAQ,IAAI,MAAM,MAAM,GAAG,GAAG;CAC3F,MAAM,WAAW,OAAO,QAAQ,OAAO;AAEvC,QAAO,UADa,OAAO,KAAK,IAAI,UAAU,OAAO,EAAE,OAAO,CACjC"}

package/dist/storage/enhanced/redis/keyed-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../../src/storage/enhanced/redis/keyed-store.ts"],"sourcesContent":[],"mappings":";;;;;;AAyBA;;;;;;;;;;;;;;;;;;;;;AACmE,iBADnD,6BACmD,CAAA,IAAA,OAAA,CAAA,CAAA,OAAA,EADC,UACD,CAAA,OADmB,0BACnB,CAAA,CAAA,EAAA,CAAA,UAAA,GAAA,EAAA,CAAA,CAAA,cAAA,EAAA,CAAA,GAAA,IAAA,EAAZ,CAAY,EAAA,GAAA,MAAA,EAAA,GAAA,QAAA,CAAA;EAAA,OAAA,EAAA,CAAA,GAAA,IAAA,EACxC,CADwC,EAAA,GACvC,OADuC,CACvC,CADuC,GAAA,IAAA,CAAA;wBAErC,MAAC;qBACJ,MAAC;wBACE,MAAC;;;;;;wBAMD;mBACL,YAAY,MAAC;yCACS,YAAY,IAAC"}
+{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../../src/storage/enhanced/redis/keyed-store.ts"],"sourcesContent":[],"mappings":";;;;;;AAyBA;;;;;;;;;;;;;;;;;;;;;AACmE,iBADnD,6BACmD,CAAA,IAAA,OAAA,CAAA,CAAA,OAAA,EADC,UACD,CAAA,OADmB,0BACnB,CAAA,CAAA,EAAA,CAAA,UAAA,GAAA,EAAA,CAAA,CAAA,cAAA,EAAA,CAAA,GAAA,IAAA,EAAZ,CAAY,EAAA,GAAA,MAAA,EAAA,GAAA,QAAA,CAAA;qBACxC,MAAC,QAAA;wBACE,MAAC;qBACJ,MAAC;wBACE,MAAC;;;;;;wBAMD;mBACL,YAAY,MAAC;yCACS,YAAY,IAAC"}

package/dist/time.d.ts

@@ -0,0 +1,5 @@
+//#region src/time.d.ts
+declare function abortableDelay(ms: number, signal?: AbortSignal): Promise<unknown>;
+//#endregion
+export { abortableDelay };
+//# sourceMappingURL=time.d.ts.map

package/dist/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","names":[],"sources":["../src/time.ts"],"sourcesContent":[],"mappings":";iBAAgB,cAAA,sBAAoC,cAAW"}

package/dist/time.js

@@ -0,0 +1,14 @@
+//#region src/time.ts
+function abortableDelay(ms, signal) {
+	return new Promise((resolve) => {
+		const timeout = setTimeout(resolve, ms);
+		if (signal) signal.addEventListener("abort", () => {
+			clearTimeout(timeout);
+			resolve(void 0);
+		});
+	});
+}
+
+//#endregion
+export { abortableDelay };
+//# sourceMappingURL=time.js.map

package/dist/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","names":[],"sources":["../src/time.ts"],"sourcesContent":["export function abortableDelay(ms: number, signal?: AbortSignal) {\n    return new Promise((resolve) => {\n        const timeout = setTimeout(resolve, ms);\n        if (signal) {\n            signal.addEventListener(\n                'abort',\n                () => {\n                    clearTimeout(timeout);\n                    resolve(undefined);\n                },\n            );\n        }\n    });\n}\n"],"mappings":";AAAA,SAAgB,eAAe,IAAY,QAAsB;AAC7D,QAAO,IAAI,SAAS,YAAY;EAC5B,MAAM,UAAU,WAAW,SAAS,GAAG;AACvC,MAAI,OACA,QAAO,iBACH,eACM;AACF,gBAAa,QAAQ;AACrB,WAAQ,OAAU;IAEzB;GAEP"}

package/dist/types/filtered-key-path.d.ts

@@ -10,8 +10,8 @@ import { ObjectId } from "bson";
  * Original types might have been modified to suit this project’s needs.
  */
 /***/
-type ConditionalPath<K extends number | string, V, U> = V extends U ? `${K}` : DefaultPath<K, V, U, never>;
-type DefaultPath<K extends number | string, V, U = never, RK = `${K}`> = V extends TerminalType ? RK : `${K}.${FilteredKeyPath<V, U>}`;
+type ConditionalPath<K$1 extends number | string, V$1, U> = V$1 extends U ? `${K$1}` : DefaultPath<K$1, V$1, U, never>;
+type DefaultPath<K$1 extends number | string, V$1, U = never, RK = `${K$1}`> = V$1 extends TerminalType ? RK : `${K$1}.${FilteredKeyPath<V$1, U>}`;
 /**
  * A utility type that generates a union of key paths from a given object type `T`,
  * filtered by a specific type `U`. If `U` is
@@ -22,7 +22,7 @@ type DefaultPath<K extends number | string, V, U = never, RK = `${K}`> = V exten
  */
 type FilteredKeyPath<T, U = never> = T extends ReadonlyArray<infer V> ? (IsTuple<T> extends true ? { [K in TupleKey<T>]-?: PathImpl<Exclude<K, symbol>, T[K], U> }[TupleKey<T>] : PathImpl<number, V, U>) : { [K in keyof T]-?: PathImpl<Exclude<K, symbol>, T[K], U> }[keyof T];
 type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
-type PathImpl<K extends number | string, V, U> = [U] extends [never] ? DefaultPath<K, V> : ConditionalPath<K, V, U>;
+type PathImpl<K$1 extends number | string, V$1, U> = [U] extends [never] ? DefaultPath<K$1, V$1> : ConditionalPath<K$1, V$1, U>;
 type TerminalType = bigint | Blob | boolean | Date | File | null | number | ObjectId | RegExp | string | symbol | undefined;
 type TupleKey<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
 //#endregion

package/dist/types/filtered-key-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filtered-key-path.d.ts","names":[],"sources":["../../src/types/filtered-key-path.ts"],"sourcesContent":[],"mappings":";;;;;;AAAqC;;;;;;KAWhC,eAAyF,CAAA,UAAA,MAAA,GAAA,MAAA,EAAA,CAAA,EAAA,CAAA,CAAA,GAAtC,CAAsC,SAA5B,CAA4B,GAAA,GAArB,CAAqB,EAAA,GAAf,WAAe,CAAH,CAAG,EAAA,CAAA,EAAG,CAAH,EAAA,KAAA,CAAA;KACzF,WAD4F,CAAA,UAAA,MAAA,GAAA,MAAA,EAAA,CAAA,EAAA,IAAA,KAAA,EAAA,KAAA,GAKrF,CALqF,EAAA,CAAA,GAM7F,CAN6F,SAMnF,YANmF,GAMpE,EANoE,GAAA,GAM5D,CAN4D,IAMvD,eANuD,CAMvC,CANuC,EAMpC,CANoC,CAAA,EAAA;;;AAAP;;;;;;AAMrD,KAWzB,eAXyB,CAAA,CAAA,EAAA,IAAA,KAAA,CAAA,GAWO,CAXP,SAWiB,aAXjB,CAAA,KAAA,EAAA,CAAA,GAAA,CAW2C,OAX3C,CAWmD,CAXnD,CAAA,SAAA,IAAA,GAAA,QAW6E,QAXxD,CAWiE,CAXjE,CAAA,KAWwE,QAXxE,CAWiF,OAXjF,CAWyF,CAXzF,EAAA,MAAA,CAAA,EAWqG,CAXrG,CAWuG,CAXvG,CAAA,EAW2G,CAX3G,CAAA,GAWgH,QAX7G,CAWsH,CAXtH,CAAA,CAAA,GAW4H,QAX5H,CAAA,MAAA,EAW6I,CAX7I,EAWgJ,CAXhJ,CAAA,CAAA,GAAA,QAAnB,MAWuL,CAXvL,KAW6L,QAX7L,CAWsM,OAXtM,CAW8M,CAX9M,EAAA,MAAA,CAAA,EAW0N,CAX1N,CAW4N,CAX5N,CAAA,EAWgO,CAXhO,CAAA,EAAe,CAAA,MAW4N,CAX5N,CAAA;AAWzD,KACK,OADO,CAAA,UACW,aADI,CAAA,GAAA,CAAA,CAAA,GAAA,MAAA,SACiC,CADjC,CAAA,QAAA,CAAA,GAAA,KAAA,GAAA,IAAA;KAEtB,QAFsB,CAAA,UAAA,MAAA,GAAA,MAAA,EAAA,CAAA,EAAA,CAAA,CAAA,GAAA,CAEuB,CAFvB,CAAA,SAAA,CAAA,KAAA,CAAA,GAE4C,WAF5C,CAEwD,CAFxD,EAE2D,CAF3D,CAAA,GAEgE,eAFhE,CAEgF,CAFhF,EAEmF,CAFnF,EAEsF,CAFtF,CAAA;KAGtB,YAAA,GAHuC,MAAA,GAKxC,IALwC,GAAA,OAAA,GAOxC,IAPwC,GAQxC,IARwC,GAAA,IAAA,GAAA,MAAA,GAWxC,QAXwC,GAYxC,MAZwC,GAAA,MAAA,GAAA,MAAA,GAAA,SAAA;KAiBvC,QAjBiD,CAAA,UAiB9B,aAjB8B,CAAA,GAAA,CAAA,CAAA,GAiBR,OAjBQ,CAAA,MAiBM,CAjBN,EAAA,MAAA,GAAA,EAAA,CAAA"}
+{"version":3,"file":"filtered-key-path.d.ts","names":[],"sources":["../../src/types/filtered-key-path.ts"],"sourcesContent":[],"mappings":";;;;;;AAAqC;;;;;;KAWhC,eAA4F,CAAA,YAAA,MAAA,GAAA,MAAA,EAAA,GAAA,EAAA,CAAA,CAAA,GAAzC,GAAyC,SAA/B,CAA+B,GAAA,GAAxB,GAAwB,EAAA,GAAlB,WAAkB,CAAN,GAAM,EAAH,GAAG,EAAA,CAAA,EAAA,KAAA,CAAA;KAC5F,WAD0E,CAAA,YAAA,MAAA,GAAA,MAAA,EAAA,GAAA,EAAA,IAAA,KAAA,EAAA,KAAA,GAKnE,GALmE,EAAA,CAAA,GAM3E,GAN2E,SAMjE,YANiE,GAMlD,EANkD,GAAA,GAM1C,GAN0C,IAMrC,eANqC,CAMrB,GANqB,EAMlB,CANkB,CAAA,EAAA;;AAAW;;;;;;;AAM7B,KAWjD,eAXiD,CAAA,CAAA,EAAA,IAAA,KAAA,CAAA,GAWjB,CAXiB,SAWP,aAXO,CAAA,KAAA,EAAA,CAAA,GAAA,CAWmB,OAXnB,CAW2B,CAX3B,CAAA,SAAA,IAAA,GAAA,QAWqD,QAXxE,CAWiF,CAXjF,CAAA,KAWwF,QAXxF,CAWiG,OAXjG,CAWyG,CAXzG,EAAA,MAAA,CAAA,EAWqH,CAXrH,CAWuH,CAXvH,CAAA,EAW2H,CAX3H,CAAA,EAAe,CAWiH,QAXjH,CAW0H,CAX1H,CAAA,CAAA,GAWgI,QAXhI,CAAA,MAAA,EAWiJ,CAXjJ,EAWoJ,CAXpJ,CAAA,CAAA,GAAA,QAW7C,MAAqN,CAArN,KAA2N,QAA5M,CAAqN,OAArN,CAA6N,CAA7N,EAAA,MAAA,CAAA,EAAyO,CAAzO,CAA2O,CAA3O,CAAA,EAA+O,CAA/O,CAAA,EAAiB,CAAA,MAAyO,CAAzO,CAAA;KACvC,OADiD,CAAA,UAC/B,aAD+B,CAAA,GAAA,CAAA,CAAA,GAAA,MAAA,SACM,CADN,CAAA,QAAA,CAAA,GAAA,KAAA,GAAA,IAAA;KAEjD,QAFmF,CAAA,YAAA,MAAA,GAAA,MAAA,EAAA,GAAA,EAAA,CAAA,CAAA,GAAA,CAEtC,CAFsC,CAAA,SAAA,CAAA,KAAA,CAAA,GAEjB,WAFiB,CAEL,GAFK,EAEF,GAFE,CAAA,GAEG,eAFH,CAEmB,GAFnB,EAEsB,GAFtB,EAEyB,CAFzB,CAAA;KAGnF,YAAA,GAH2E,MAAA,GAK5E,IAL4E,GAAA,OAAA,GAO5E,IAP4E,GAQ5E,IAR4E,GAAA,IAAA,GAAA,MAAA,GAW5E,QAX4E,GAY5E,MAZ4E,GAAA,MAAA,GAAA,MAAA,GAAA,SAAA;KAiB3E,QAjBsH,CAAA,UAiBnG,aAjBmG,CAAA,GAAA,CAAA,CAAA,GAiB7E,OAjB6E,CAAA,MAiB/D,CAjB+D,EAAA,MAAA,GAAA,EAAA,CAAA"}

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":";;;;KAQY,SAAA,GAAY;KACZ,WAAA,GAAc,OAAO,SAAS,OAAO,SAAW;AADhD,KAEA,UAAA,GAFS,OAAG,GAAM,MAAA,GAAA,OAAA;AAClB,KAEA,YAFW,CAAA,CAAA,CAAA,GAEO,OAFP,CAEe,CAFf,CAAA,GAEoB,CAFpB;AAAA,KAGX,aAHW,CAAA,CAAA,CAAA,GAGQ,QAHR,CAGiB,CAHjB,CAAA,GAGsB,CAHtB;AAAG,KAId,QAJc,CAAA,CAAA,CAAA,GAAA,IAAA,GAIO,CAJP;AAAO,KAKrB,SAAA,GALqB,MAAA,GAAA,MAAA;AAAS,KAM9B,aAN8B,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAMU,OANV,CAMkB,MANlB,CAMyB,CANzB,EAM4B,CAN5B,CAAA,CAAA;AAAO,KAOrC,qBAPqC,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAOW,QAPX,CAOoB,aAPpB,CAOkC,CAPlC,EAOqC,CAPrC,CAAA,CAAA;AAAW,KAQhD,cARgD,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAQP,QARO,CAQE,MARF,CAQS,CART,EAQY,CARZ,CAAA,CAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":";;;;KAQY,SAAA,GAAY;KACZ,WAAA,GAAc,OAAO,SAAS,OAAO,SAAW;AADhD,KAEA,UAAA,GAFS,OAAG,GAAM,MAAA,GAAA,OAAA;AAClB,KAEA,YAFW,CAAA,CAAA,CAAA,GAEO,OAFP,CAEe,CAFf,CAAA,GAEoB,CAFpB;AAAG,KAGd,aAHc,CAAA,CAAA,CAAA,GAGK,QAHL,CAGc,CAHd,CAAA,GAGmB,CAHnB;AAAO,KAIrB,QAJqB,CAAA,CAAA,CAAA,GAAA,IAAA,GAIA,CAJA;AAAS,KAK9B,SAAA,GAL8B,MAAA,GAAA,MAAA;AAAO,KAMrC,aANqC,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAMG,OANH,CAMW,MANX,CAMkB,CANlB,EAMqB,CANrB,CAAA,CAAA;AAAW,KAOhD,qBAPgD,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAOA,QAPA,CAOS,aAPT,CAOuB,CAPvB,EAO0B,CAP1B,CAAA,CAAA;AAAQ,KAQxD,cARwD,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAQf,QARe,CAQN,MARM,CAQC,CARD,EAQI,CARJ,CAAA,CAAA"}

package/dist/vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue.d.ts","names":[],"sources":["../src/vue.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;AASA;;;;AAAkD,iBATlC,wCAAA,CASkC,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;;AAUlD;;;AAAyD,iBAVzC,gBAAA,CAUyC,WAAA,EAVX,GAUW,CAVP,QAUO,CAVE,UAUF,CAAA,OAVoB,WAUpB,CAAA,CAAA,CAAA,CAAA,EAAA,IAAA;;;;AAazD;;AAA4C,iBAb5B,eAAA,CAa4B,UAAA,EAbA,GAaA,CAbI,QAaJ,CAba,UAab,CAAA,OAb+B,UAa/B,CAAA,CAAA,CAAA,CAAA,EAAA,IAAA;;;;;;;;;iBAA5B,4BAA4B,UAAU,2BAA2B,IAAI,SAAS"}
+{"version":3,"file":"vue.d.ts","names":[],"sources":["../src/vue.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;AASA;;;;AAA8C,iBAT9B,wCAAA,CAS8B,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;AAU9C;;;;AAA4C,iBAV5B,gBAAA,CAU4B,WAAA,EAVE,GAUF,CAVM,QAUN,CAVe,UAUf,CAAA,OAViC,WAUjC,CAAA,CAAA,CAAA,CAAA,EAAA,IAAA;;AAa5C;;;;AAAqF,iBAbrE,eAAA,CAaqE,UAAA,EAbzC,GAayC,CAbrC,QAaqC,CAb5B,UAa4B,CAAA,OAbV,UAaU,CAAA,CAAA,CAAA,CAAA,EAAA,IAAA;;;;;;;;;iBAArE,4BAA4B,UAAU,2BAA2B,IAAI,SAAS"}

package/dist/web.js

@@ -9,8 +9,7 @@ import { appendRedirectParamToUrl } from "./url.js";
 * @returns {string} A new URL with the current location as the `redirect` parameter
 */
 function appendRedirectParamFromCurrentLocationToUrl(url) {
-	const currentPath = `${window.location.pathname}${window.location.search}${window.location.hash}`;
-	return appendRedirectParamToUrl(url, currentPath);
+	return appendRedirectParamToUrl(url, `${window.location.pathname}${window.location.search}${window.location.hash}`);
 }
 /**
 * Navigates to the given URL, appending the current browser location

package/dist/web.js.map

@@ -1 +1 @@
-{"version":3,"file":"web.js","names":[],"sources":["../src/web.ts"],"sourcesContent":["import { appendRedirectParamToUrl } from './url';\n\n/**\n * Appends the current browser URL (including path, query, and hash) as the `redirect` query parameter to the given URL.\n *\n * @param {string} url - The base URL to modify\n *\n * @returns {string} A new URL with the current location as the `redirect` parameter\n */\nexport function appendRedirectParamFromCurrentLocationToUrl(url: string) {\n    const currentPath = `${window.location.pathname}${window.location.search}${window.location.hash}`;\n    return appendRedirectParamToUrl(url, currentPath);\n}\n\n/**\n * Navigates to the given URL, appending the current browser location\n * (path, query, and hash) as the `redirect` query parameter.\n *\n * Useful for redirecting to login or other gateways while preserving\n * the current location for post-auth navigation.\n *\n * @param {string} url - The destination URL to navigate to\n * @param {number} [delayMs] - Optional delay in milliseconds before navigation\n */\nexport function assignUrlWithRedirectParamFromCurrentLocation(url: string, delayMs?: number) {\n    if (delayMs === undefined) window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url));\n    else return setTimeout(() => window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url)), delayMs);\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,4CAA4C,KAAa;CACrE,MAAM,cAAc,GAAG,OAAO,SAAS,WAAW,OAAO,SAAS,SAAS,OAAO,SAAS;AAC3F,QAAO,yBAAyB,KAAK,YAAY;;;;;;;;;;;;AAarD,SAAgB,8CAA8C,KAAa,SAAkB;AACzF,KAAI,YAAY,OAAW,QAAO,SAAS,OAAO,4CAA4C,IAAI,CAAC;KAC9F,QAAO,iBAAiB,OAAO,SAAS,OAAO,4CAA4C,IAAI,CAAC,EAAE,QAAQ"}
+{"version":3,"file":"web.js","names":[],"sources":["../src/web.ts"],"sourcesContent":["import { appendRedirectParamToUrl } from './url';\n\n/**\n * Appends the current browser URL (including path, query, and hash) as the `redirect` query parameter to the given URL.\n *\n * @param {string} url - The base URL to modify\n *\n * @returns {string} A new URL with the current location as the `redirect` parameter\n */\nexport function appendRedirectParamFromCurrentLocationToUrl(url: string) {\n    const currentPath = `${window.location.pathname}${window.location.search}${window.location.hash}`;\n    return appendRedirectParamToUrl(url, currentPath);\n}\n\n/**\n * Navigates to the given URL, appending the current browser location\n * (path, query, and hash) as the `redirect` query parameter.\n *\n * Useful for redirecting to login or other gateways while preserving\n * the current location for post-auth navigation.\n *\n * @param {string} url - The destination URL to navigate to\n * @param {number} [delayMs] - Optional delay in milliseconds before navigation\n */\nexport function assignUrlWithRedirectParamFromCurrentLocation(url: string, delayMs?: number) {\n    if (delayMs === undefined) window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url));\n    else return setTimeout(() => window.location.assign(appendRedirectParamFromCurrentLocationToUrl(url)), delayMs);\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,4CAA4C,KAAa;AAErE,QAAO,yBAAyB,KADZ,GAAG,OAAO,SAAS,WAAW,OAAO,SAAS,SAAS,OAAO,SAAS,OAC1C;;;;;;;;;;;;AAarD,SAAgB,8CAA8C,KAAa,SAAkB;AACzF,KAAI,YAAY,OAAW,QAAO,SAAS,OAAO,4CAA4C,IAAI,CAAC;KAC9F,QAAO,iBAAiB,OAAO,SAAS,OAAO,4CAA4C,IAAI,CAAC,EAAE,QAAQ"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kikiutils/shared",
   "type": "module",
-  "version": "13.5.1",
+  "version": "13.6.0",
   "description": "A lightweight and modular utility library for modern JavaScript and TypeScript — includes secure hashing, flexible logging, datetime tools, Vue/web helpers, storage abstraction, and more.",
   "author": "kiki-kanri",
   "license": "MIT",
@@ -93,7 +93,7 @@
     "@types/node": "^24.5.2",
     "@types/ssh2": "^1.15.5",
     "async-validator": "^4.2.5",
-    "bson": "^6.10.4",
+    "bson": "^7.0.0",
     "consola": "^3.4.2",
     "date-fns": "^4.1.0",
     "decimal.js": "^10.6.0",
@@ -103,7 +103,7 @@
     "lru-cache": "^11.2.1",
     "millify": "^6.1.0",
     "node-ssh": "^13.2.1",
-    "pino": "^9.10.0",
+    "pino": "^10.0.0",
     "pino-pretty": "^13.1.1",
     "superjson": "^2.2.2",
     "vue": "^3.5.21",
@@ -175,47 +175,48 @@
     }
   },
   "devDependencies": {
-    "@kikiutils/changelogen": "^0.9.0",
-    "@kikiutils/eslint-config": "^3.0.1",
+    "@antfu/eslint-config": "^6.2.0",
+    "@kikiutils/eslint-config": "^5.0.0",
     "@kikiutils/tsconfigs": "^5.0.5",
-    "@noble/hashes": "^2.0.0",
+    "@noble/hashes": "^2.0.1",
     "@types/fs-extra": "^11.0.4",
     "@types/jsonfile": "^6.1.4",
-    "@types/node": "^24.5.2",
+    "@types/node": "^24.10.1",
     "@types/ssh2": "^1.15.5",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.0.10",
     "async-validator": "^4.2.5",
-    "bson": "^6.10.4",
+    "bson": "^7.0.0",
+    "changelogen": "^0.6.2",
     "consola": "^3.4.2",
-    "cross-env": "^10.0.0",
+    "cross-env": "^10.1.0",
     "date-fns": "^4.1.0",
     "decimal.js": "^10.6.0",
     "depcheck": "^1.4.7",
-    "element-plus": "^2.11.3",
+    "element-plus": "^2.11.8",
     "fs-extra": "^11.3.2",
-    "ioredis": "^5.7.0",
-    "jsdom": "^27.0.0",
-    "lru-cache": "^11.2.1",
+    "ioredis": "^5.8.2",
+    "jsdom": "^27.2.0",
+    "lru-cache": "^11.2.2",
     "millify": "^6.1.0",
     "node-ssh": "^13.2.1",
-    "pino": "^9.10.0",
-    "pino-pretty": "^13.1.1",
-    "publint": "^0.3.13",
-    "superjson": "^2.2.2",
+    "pino": "^10.1.0",
+    "pino-pretty": "^13.1.2",
+    "publint": "^0.3.15",
+    "redis": "^5.9.0",
+    "superjson": "^2.2.5",
     "ts-unused-exports": "^11.0.1",
-    "tsdown": "^0.15.2",
-    "typescript": "^5.9.2",
-    "unplugin-unused": "^0.5.3",
-    "vitest": "^3.2.4",
-    "vue": "^3.5.21",
-    "vue-router": "^4.5.1"
+    "tsdown": "^0.16.5",
+    "typescript": "^5.9.3",
+    "unplugin-unused": "^0.5.6",
+    "vitest": "^4.0.10",
+    "vue": "^3.5.24",
+    "vue-router": "^4.6.3"
   },
   "pnpm": {
     "onlyBuiltDependencies": [
       "cpu-features",
       "esbuild",
       "ssh2",
-      "unrs-resolver",
       "vue-demi"
     ]
   }

package/src/buffer.ts

@@ -1,8 +1,6 @@
 import { Buffer } from 'node:buffer';
-import type {
-    Blob as NodeBlob,
-    File as NodeFile,
-} from 'node:buffer';
+
+import type { BinaryInput } from './types';
 
 /**
  * Converts a Blob, Buffer, or File to a Buffer.
@@ -35,7 +33,7 @@ import type {
  * console.log(result3.toString()); // 'File content'
  * ```
  */
-export async function toBuffer(input: Blob | Buffer | File | NodeBlob | NodeFile) {
+export async function toBuffer(input: BinaryInput) {
     if (Buffer.isBuffer(input)) return input;
     return Buffer.from(await input.arrayBuffer());
 }

package/src/hash.ts

@@ -17,11 +17,11 @@ import {
     sha3_256,
     sha3_384,
     sha3_512,
-} from '@noble/hashes/sha3';
+} from '@noble/hashes/sha3.js';
 import {
     bytesToHex,
     utf8ToBytes,
-} from '@noble/hashes/utils';
+} from '@noble/hashes/utils.js';
 
 export function sha3224(data: string | Uint8Array) {
     return bytesToHex(sha3_224(typeof data === 'string' ? utf8ToBytes(data) : data));

package/src/object.ts

@@ -30,12 +30,12 @@ export function stringifyObjectDeterministically(
 
     function walk(object: any, path: string[] = []) {
         if (Array.isArray(object)) {
-            object.forEach((value, index) => {
+            object.forEach((value, i) => {
                 walk(
                     value,
                     [
                         ...path,
-                        index.toString(),
+                        i.toString(),
                     ],
                 );
             });

package/src/time.ts

@@ -0,0 +1,14 @@
+export function abortableDelay(ms: number, signal?: AbortSignal) {
+    return new Promise((resolve) => {
+        const timeout = setTimeout(resolve, ms);
+        if (signal) {
+            signal.addEventListener(
+                'abort',
+                () => {
+                    clearTimeout(timeout);
+                    resolve(undefined);
+                },
+            );
+        }
+    });
+}