@kikiutils/shared 14.0.1 → 14.1.1

package/dist/buffer.d.ts

@@ -4,34 +4,33 @@ import { Buffer } from "node:buffer";
 //#region src/buffer.d.ts
 
 /**
- * Converts a Blob, Buffer, or File to a Buffer.
+ * Converts various binary data types to a Node.js Buffer.
  *
- * This function provides a unified way to convert various binary data types
- * to Node.js Buffer. If the input is already a Buffer, it returns it as-is.
- * For Blob or File inputs, it converts them to Buffer via ArrayBuffer.
+ * This function provides a unified, efficient way to convert different binary formats
+ * (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.
+ * It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure
+ * optimal performance.
  *
- * @param {Blob | Buffer | File} input - The input to convert to Buffer
+ * @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.
+ * Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.
  *
- * @returns {Promise<Buffer>} A Promise that resolves to a Buffer
+ * @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.
  *
  * @example
  * ```typescript
- * import { toBuffer } from '@kikiutils/shared/general';
+ * import { toBuffer } from '@kikiutils/shared/buffer';
  *
- * // Convert a Buffer (returns as-is)
- * const buffer = Buffer.from('Hello World');
- * const result1 = await toBuffer(buffer);
- * console.log(result1); // <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>
+ * // From ArrayBuffer
+ * const ab = new ArrayBuffer(8);
+ * const bufferFromAB = await toBuffer(ab);
  *
- * // Convert a Blob
- * const blob = new Blob(['Hello from Blob'], { type: 'text/plain' });
- * const result2 = await toBuffer(blob);
- * console.log(result2.toString()); // 'Hello from Blob'
+ * // From Uint8Array (Zero-copy)
+ * const u8 = new Uint8Array([10, 20, 30]);
+ * const bufferFromU8 = await toBuffer(u8);
  *
- * // Convert a File
- * const file = new File(['File content'], 'test.txt', { type: 'text/plain' });
- * const result3 = await toBuffer(file);
- * console.log(result3.toString()); // 'File content'
+ * // From Blob or File
+ * const blob = new Blob(['data'], { type: 'text/plain' });
+ * const bufferFromBlob = await toBuffer(blob);
  * ```
  */
 declare function toBuffer(input: BinaryInput): Promise<Buffer<ArrayBufferLike>>;

package/dist/buffer.d.ts.map

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

package/dist/buffer.js

@@ -2,39 +2,41 @@ import { Buffer } from "node:buffer";
 
 //#region src/buffer.ts
 /**
-* Converts a Blob, Buffer, or File to a Buffer.
+* Converts various binary data types to a Node.js Buffer.
 *
-* This function provides a unified way to convert various binary data types
-* to Node.js Buffer. If the input is already a Buffer, it returns it as-is.
-* For Blob or File inputs, it converts them to Buffer via ArrayBuffer.
+* This function provides a unified, efficient way to convert different binary formats
+* (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.
+* It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure
+* optimal performance.
 *
-* @param {Blob | Buffer | File} input - The input to convert to Buffer
+* @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.
+* Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.
 *
-* @returns {Promise<Buffer>} A Promise that resolves to a Buffer
+* @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.
 *
 * @example
 * ```typescript
-* import { toBuffer } from '@kikiutils/shared/general';
+* import { toBuffer } from '@kikiutils/shared/buffer';
 *
-* // Convert a Buffer (returns as-is)
-* const buffer = Buffer.from('Hello World');
-* const result1 = await toBuffer(buffer);
-* console.log(result1); // <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>
+* // From ArrayBuffer
+* const ab = new ArrayBuffer(8);
+* const bufferFromAB = await toBuffer(ab);
 *
-* // Convert a Blob
-* const blob = new Blob(['Hello from Blob'], { type: 'text/plain' });
-* const result2 = await toBuffer(blob);
-* console.log(result2.toString()); // 'Hello from Blob'
+* // From Uint8Array (Zero-copy)
+* const u8 = new Uint8Array([10, 20, 30]);
+* const bufferFromU8 = await toBuffer(u8);
 *
-* // Convert a File
-* const file = new File(['File content'], 'test.txt', { type: 'text/plain' });
-* const result3 = await toBuffer(file);
-* console.log(result3.toString()); // 'File content'
+* // From Blob or File
+* const blob = new Blob(['data'], { type: 'text/plain' });
+* const bufferFromBlob = await toBuffer(blob);
 * ```
 */
 async function toBuffer(input) {
 	if (Buffer.isBuffer(input)) return input;
-	return Buffer.from(await input.arrayBuffer());
+	if (input instanceof ArrayBuffer) return Buffer.from(input);
+	if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+	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

package/dist/buffer.js.map

@@ -1 +1 @@
-{"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"}
+{"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 various binary data types to a Node.js Buffer.\n *\n * This function provides a unified, efficient way to convert different binary formats\n * (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.\n * It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure\n * optimal performance.\n *\n * @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.\n * Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.\n *\n * @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.\n *\n * @example\n * ```typescript\n * import { toBuffer } from '@kikiutils/shared/buffer';\n *\n * // From ArrayBuffer\n * const ab = new ArrayBuffer(8);\n * const bufferFromAB = await toBuffer(ab);\n *\n * // From Uint8Array (Zero-copy)\n * const u8 = new Uint8Array([10, 20, 30]);\n * const bufferFromU8 = await toBuffer(u8);\n *\n * // From Blob or File\n * const blob = new Blob(['data'], { type: 'text/plain' });\n * const bufferFromBlob = await toBuffer(blob);\n * ```\n */\nexport async function toBuffer(input: BinaryInput) {\n    if (Buffer.isBuffer(input)) return input;\n    if (input instanceof ArrayBuffer) return Buffer.from(input);\n    if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength);\n    if (typeof input.arrayBuffer === 'function') return Buffer.from(await input.arrayBuffer());\n    // eslint-disable-next-line style/max-len\n    throw new TypeError('The provided input is not a supported binary type (Blob, Buffer, File, ArrayBuffer, or Uint8Array).');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,eAAsB,SAAS,OAAoB;AAC/C,KAAI,OAAO,SAAS,MAAM,CAAE,QAAO;AACnC,KAAI,iBAAiB,YAAa,QAAO,OAAO,KAAK,MAAM;AAC3D,KAAI,iBAAiB,WAAY,QAAO,OAAO,KAAK,MAAM,QAAQ,MAAM,YAAY,MAAM,WAAW;AACrG,KAAI,OAAO,MAAM,gBAAgB,WAAY,QAAO,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAE1F,OAAM,IAAI,UAAU,sGAAsG"}

package/dist/datetime.js.map

@@ -1 +1 @@
-{"version":3,"file":"datetime.js","names":["dateFnsFormat","format","endDate: Date","startDate: Date"],"sources":["../src/datetime.ts"],"sourcesContent":["import {\n    format as dateFnsFormat,\n    endOfDay,\n    endOfMonth,\n    endOfWeek,\n    startOfDay,\n    startOfMonth,\n    startOfWeek,\n    subDays,\n    subMonths,\n    subWeeks,\n} from 'date-fns';\nimport type {\n    DateArg,\n    Day,\n    FormatOptions,\n} from 'date-fns';\n\nexport type DateRangeType = 'lastMonth' | 'lastWeek' | 'thisMonth' | 'thisWeek' | 'today' | 'yesterday';\n\n/**\n * Formats a given date, timestamp, or date string into a specified format.\n *\n * This function is a wrapper around `date-fns/format`.\n *\n * @param {DateArg<Date>} date - The input date to format. Can be a Date object, a timestamp, or a string\n * @param {string} [format] - The target format string\n * @param {FormatOptions} [options] - Optional formatting options passed to `date-fns/format`\n *\n * @returns {string} The formatted date string\n *\n * @example\n * ```typescript\n * import { formatDate } from '@kikiutils/shared/datetime';\n *\n * // Format a Date object\n * console.log(formatDate(new Date(), 'yyyy-MM-dd')); // 2024-07-10\n *\n * // Format a timestamp\n * console.log(formatDate(1657814400000, 'yyyy-MM-dd')); // 2022-07-15\n *\n * // Format a date string\n * console.log(formatDate('2024-07-10T00:00:00Z', 'yyyy-MM-dd')); // 2024-07-10\n * ```\n *\n * @see https://date-fns.org/docs/format\n */\nexport function formatDate(date: DateArg<Date> & {}, format: string = 'yyyy-MM-dd HH:mm:ss', options?: FormatOptions) {\n    return dateFnsFormat(date, format, options);\n}\n\n/**\n * Get the date range (start and end) based on a given date and range type.\n *\n * Supports common range types like 'lastMonth', 'lastWeek', 'thisMonth', 'thisWeek', 'today', and 'yesterday'.\n *\n * @param {Date} date - The reference date\n * @param {DateRangeType} type - The range type to compute\n * @param {object} [options] - Optional settings\n * @param {boolean} [options.setEndDateToNextDayStart] - If true, set `endDate` to 00:00:00.000 of the next day\n * @param {Day} [options.weekStartsOn] - The start day of the week (0 = Sunday, 1 = Monday, ..., 6 = Saturday)\n *\n * @returns {{ startDate: Date, endDate: Date }} An object with `startDate` and `endDate`\n *\n * @example\n * ```typescript\n * import { getDateRangeFromDate } from '@kikiutils/shared/datetime';\n *\n * // Get the date range for last month\n * const date = new Date('2023-07-01');\n * console.log(getDateRangeFromDate(date, 'lastMonth'));\n * // { startDate: 2023-06-01T00:00:00.000Z, endDate: 2023-06-30T23:59:59.999Z }\n *\n * // Get this week's range with Sunday as the first day\n * console.log(getDateRangeFromDate(date, 'thisWeek', { weekStartsOn: 0 }));\n * // { startDate: 2023-06-25T00:00:00.000Z, endDate: 2023-07-01T23:59:59.999Z }\n * ```\n */\nexport function getDateRangeFromDate(\n    date: Date,\n    type: DateRangeType,\n    options?: {\n        setEndDateToNextDayStart?: boolean;\n        weekStartsOn?: Day;\n    },\n) {\n    let endDate: Date;\n    let startDate: Date;\n    switch (type) {\n        case 'lastMonth':\n            {\n                const lastMonth = subMonths(date, 1);\n                endDate = endOfMonth(lastMonth);\n                startDate = startOfMonth(lastMonth);\n            }\n\n            break;\n        case 'lastWeek':\n            {\n                const lastWeek = subWeeks(date, 1);\n                endDate = endOfWeek(lastWeek, { weekStartsOn: options?.weekStartsOn ?? 1 });\n                startDate = startOfWeek(lastWeek, { weekStartsOn: options?.weekStartsOn ?? 1 });\n            }\n\n            break;\n        case 'thisMonth':\n            endDate = endOfMonth(date);\n            startDate = startOfMonth(date);\n            break;\n        case 'thisWeek':\n            endDate = endOfWeek(date, { weekStartsOn: options?.weekStartsOn ?? 1 });\n            startDate = startOfWeek(date, { weekStartsOn: options?.weekStartsOn ?? 1 });\n            break;\n        case 'today':\n            endDate = endOfDay(date);\n            startDate = startOfDay(date);\n            break;\n        case 'yesterday':\n            {\n                const yesterday = subDays(date, 1);\n                endDate = endOfDay(yesterday);\n                startDate = startOfDay(yesterday);\n            }\n\n            break;\n        default: throw new Error(`Unsupported date range type: ${type}`);\n    }\n\n    if (options?.setEndDateToNextDayStart) endDate.setHours(24, 0, 0, 0);\n    return {\n        endDate,\n        startDate,\n    };\n}\n\n/**\n * Returns a `Date` object set to midnight (00:00:00) of today, with an optional day offset.\n *\n * @param {number} [offsetDays] - Number of days to offset from today. Can be negative\n *\n * @returns {Date} A `Date` object at 00:00:00 of the offset day\n *\n * @example\n * ```typescript\n * import { getMidnightDateFromToday } from '@kikiutils/shared/datetime';\n *\n * console.log(getMidnightDateFromToday()); // today at 00:00:00\n * console.log(getMidnightDateFromToday(3)); // 3 days from today at 00:00:00\n * console.log(getMidnightDateFromToday(-1)); // yesterday at 00:00:00\n * ```\n */\nexport function getMidnightDateFromToday(offsetDays: number = 0) {\n    const date = new Date();\n    date.setDate(date.getDate() + offsetDays);\n    date.setHours(0, 0, 0, 0);\n    return date;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,WAAW,MAA0B,WAAiB,uBAAuB,SAAyB;AAClH,QAAOA,OAAc,MAAMC,UAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B/C,SAAgB,qBACZ,MACA,MACA,SAIF;CACE,IAAIC;CACJ,IAAIC;AACJ,SAAQ,MAAR;EACI,KAAK;GACD;IACI,MAAM,YAAY,UAAU,MAAM,EAAE;AACpC,cAAU,WAAW,UAAU;AAC/B,gBAAY,aAAa,UAAU;;AAGvC;EACJ,KAAK;GACD;IACI,MAAM,WAAW,SAAS,MAAM,EAAE;AAClC,cAAU,UAAU,UAAU,EAAE,cAAc,SAAS,gBAAgB,GAAG,CAAC;AAC3E,gBAAY,YAAY,UAAU,EAAE,cAAc,SAAS,gBAAgB,GAAG,CAAC;;AAGnF;EACJ,KAAK;AACD,aAAU,WAAW,KAAK;AAC1B,eAAY,aAAa,KAAK;AAC9B;EACJ,KAAK;AACD,aAAU,UAAU,MAAM,EAAE,cAAc,SAAS,gBAAgB,GAAG,CAAC;AACvE,eAAY,YAAY,MAAM,EAAE,cAAc,SAAS,gBAAgB,GAAG,CAAC;AAC3E;EACJ,KAAK;AACD,aAAU,SAAS,KAAK;AACxB,eAAY,WAAW,KAAK;AAC5B;EACJ,KAAK;GACD;IACI,MAAM,YAAY,QAAQ,MAAM,EAAE;AAClC,cAAU,SAAS,UAAU;AAC7B,gBAAY,WAAW,UAAU;;AAGrC;EACJ,QAAS,OAAM,IAAI,MAAM,gCAAgC,OAAO;;AAGpE,KAAI,SAAS,yBAA0B,SAAQ,SAAS,IAAI,GAAG,GAAG,EAAE;AACpE,QAAO;EACH;EACA;EACH;;;;;;;;;;;;;;;;;;AAmBL,SAAgB,yBAAyB,aAAqB,GAAG;CAC7D,MAAM,uBAAO,IAAI,MAAM;AACvB,MAAK,QAAQ,KAAK,SAAS,GAAG,WAAW;AACzC,MAAK,SAAS,GAAG,GAAG,GAAG,EAAE;AACzB,QAAO"}
+{"version":3,"file":"datetime.js","names":["dateFnsFormat","format"],"sources":["../src/datetime.ts"],"sourcesContent":["import {\n    format as dateFnsFormat,\n    endOfDay,\n    endOfMonth,\n    endOfWeek,\n    startOfDay,\n    startOfMonth,\n    startOfWeek,\n    subDays,\n    subMonths,\n    subWeeks,\n} from 'date-fns';\nimport type {\n    DateArg,\n    Day,\n    FormatOptions,\n} from 'date-fns';\n\nexport type DateRangeType = 'lastMonth' | 'lastWeek' | 'thisMonth' | 'thisWeek' | 'today' | 'yesterday';\n\n/**\n * Formats a given date, timestamp, or date string into a specified format.\n *\n * This function is a wrapper around `date-fns/format`.\n *\n * @param {DateArg<Date>} date - The input date to format. Can be a Date object, a timestamp, or a string\n * @param {string} [format] - The target format string\n * @param {FormatOptions} [options] - Optional formatting options passed to `date-fns/format`\n *\n * @returns {string} The formatted date string\n *\n * @example\n * ```typescript\n * import { formatDate } from '@kikiutils/shared/datetime';\n *\n * // Format a Date object\n * console.log(formatDate(new Date(), 'yyyy-MM-dd')); // 2024-07-10\n *\n * // Format a timestamp\n * console.log(formatDate(1657814400000, 'yyyy-MM-dd')); // 2022-07-15\n *\n * // Format a date string\n * console.log(formatDate('2024-07-10T00:00:00Z', 'yyyy-MM-dd')); // 2024-07-10\n * ```\n *\n * @see https://date-fns.org/docs/format\n */\nexport function formatDate(date: DateArg<Date> & {}, format: string = 'yyyy-MM-dd HH:mm:ss', options?: FormatOptions) {\n    return dateFnsFormat(date, format, options);\n}\n\n/**\n * Get the date range (start and end) based on a given date and range type.\n *\n * Supports common range types like 'lastMonth', 'lastWeek', 'thisMonth', 'thisWeek', 'today', and 'yesterday'.\n *\n * @param {Date} date - The reference date\n * @param {DateRangeType} type - The range type to compute\n * @param {object} [options] - Optional settings\n * @param {boolean} [options.setEndDateToNextDayStart] - If true, set `endDate` to 00:00:00.000 of the next day\n * @param {Day} [options.weekStartsOn] - The start day of the week (0 = Sunday, 1 = Monday, ..., 6 = Saturday)\n *\n * @returns {{ startDate: Date, endDate: Date }} An object with `startDate` and `endDate`\n *\n * @example\n * ```typescript\n * import { getDateRangeFromDate } from '@kikiutils/shared/datetime';\n *\n * // Get the date range for last month\n * const date = new Date('2023-07-01');\n * console.log(getDateRangeFromDate(date, 'lastMonth'));\n * // { startDate: 2023-06-01T00:00:00.000Z, endDate: 2023-06-30T23:59:59.999Z }\n *\n * // Get this week's range with Sunday as the first day\n * console.log(getDateRangeFromDate(date, 'thisWeek', { weekStartsOn: 0 }));\n * // { startDate: 2023-06-25T00:00:00.000Z, endDate: 2023-07-01T23:59:59.999Z }\n * ```\n */\nexport function getDateRangeFromDate(\n    date: Date,\n    type: DateRangeType,\n    options?: {\n        setEndDateToNextDayStart?: boolean;\n        weekStartsOn?: Day;\n    },\n) {\n    let endDate: Date;\n    let startDate: Date;\n    switch (type) {\n        case 'lastMonth':\n            {\n                const lastMonth = subMonths(date, 1);\n                endDate = endOfMonth(lastMonth);\n                startDate = startOfMonth(lastMonth);\n            }\n\n            break;\n        case 'lastWeek':\n            {\n                const lastWeek = subWeeks(date, 1);\n                endDate = endOfWeek(lastWeek, { weekStartsOn: options?.weekStartsOn ?? 1 });\n                startDate = startOfWeek(lastWeek, { weekStartsOn: options?.weekStartsOn ?? 1 });\n            }\n\n            break;\n        case 'thisMonth':\n            endDate = endOfMonth(date);\n            startDate = startOfMonth(date);\n            break;\n        case 'thisWeek':\n            endDate = endOfWeek(date, { weekStartsOn: options?.weekStartsOn ?? 1 });\n            startDate = startOfWeek(date, { weekStartsOn: options?.weekStartsOn ?? 1 });\n            break;\n        case 'today':\n            endDate = endOfDay(date);\n            startDate = startOfDay(date);\n            break;\n        case 'yesterday':\n            {\n                const yesterday = subDays(date, 1);\n                endDate = endOfDay(yesterday);\n                startDate = startOfDay(yesterday);\n            }\n\n            break;\n        default: throw new Error(`Unsupported date range type: ${type}`);\n    }\n\n    if (options?.setEndDateToNextDayStart) endDate.setHours(24, 0, 0, 0);\n    return {\n        endDate,\n        startDate,\n    };\n}\n\n/**\n * Returns a `Date` object set to midnight (00:00:00) of today, with an optional day offset.\n *\n * @param {number} [offsetDays] - Number of days to offset from today. Can be negative\n *\n * @returns {Date} A `Date` object at 00:00:00 of the offset day\n *\n * @example\n * ```typescript\n * import { getMidnightDateFromToday } from '@kikiutils/shared/datetime';\n *\n * console.log(getMidnightDateFromToday()); // today at 00:00:00\n * console.log(getMidnightDateFromToday(3)); // 3 days from today at 00:00:00\n * console.log(getMidnightDateFromToday(-1)); // yesterday at 00:00:00\n * ```\n */\nexport function getMidnightDateFromToday(offsetDays: number = 0) {\n    const date = new Date();\n    date.setDate(date.getDate() + offsetDays);\n    date.setHours(0, 0, 0, 0);\n    return date;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,WAAW,MAA0B,WAAiB,uBAAuB,SAAyB;AAClH,QAAOA,OAAc,MAAMC,UAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B/C,SAAgB,qBACZ,MACA,MACA,SAIF;CACE,IAAI;CACJ,IAAI;AACJ,SAAQ,MAAR;EACI,KAAK;GACD;IACI,MAAM,YAAY,UAAU,MAAM,EAAE;AACpC,cAAU,WAAW,UAAU;AAC/B,gBAAY,aAAa,UAAU;;AAGvC;EACJ,KAAK;GACD;IACI,MAAM,WAAW,SAAS,MAAM,EAAE;AAClC,cAAU,UAAU,UAAU,EAAE,cAAc,SAAS,gBAAgB,GAAG,CAAC;AAC3E,gBAAY,YAAY,UAAU,EAAE,cAAc,SAAS,gBAAgB,GAAG,CAAC;;AAGnF;EACJ,KAAK;AACD,aAAU,WAAW,KAAK;AAC1B,eAAY,aAAa,KAAK;AAC9B;EACJ,KAAK;AACD,aAAU,UAAU,MAAM,EAAE,cAAc,SAAS,gBAAgB,GAAG,CAAC;AACvE,eAAY,YAAY,MAAM,EAAE,cAAc,SAAS,gBAAgB,GAAG,CAAC;AAC3E;EACJ,KAAK;AACD,aAAU,SAAS,KAAK;AACxB,eAAY,WAAW,KAAK;AAC5B;EACJ,KAAK;GACD;IACI,MAAM,YAAY,QAAQ,MAAM,EAAE;AAClC,cAAU,SAAS,UAAU;AAC7B,gBAAY,WAAW,UAAU;;AAGrC;EACJ,QAAS,OAAM,IAAI,MAAM,gCAAgC,OAAO;;AAGpE,KAAI,SAAS,yBAA0B,SAAQ,SAAS,IAAI,GAAG,GAAG,EAAE;AACpE,QAAO;EACH;EACA;EACH;;;;;;;;;;;;;;;;;;AAmBL,SAAgB,yBAAyB,aAAqB,GAAG;CAC7D,MAAM,uBAAO,IAAI,MAAM;AACvB,MAAK,QAAQ,KAAK,SAAS,GAAG,WAAW;AACzC,MAAK,SAAS,GAAG,GAAG,GAAG,EAAE;AACzB,QAAO"}

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, 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"}
+{"version":3,"file":"object.js","names":[],"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,MAAM,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/string.js.map

@@ -1 +1 @@
-{"version":3,"file":"string.js","names":["CHARSETS: Record<RandomStringMode, string>"],"sources":["../src/string.ts"],"sourcesContent":["export type RandomStringMode =\n  | 'alphabetic'\n  | 'alphanumeric'\n  | 'lowercase'\n  | 'lowercase-numeric'\n  | 'numeric'\n  | 'uppercase'\n  | 'uppercase-numeric';\n\nconst DIGITS = '0123456789';\nconst LOWERCASE = 'abcdefghijklmnopqrstuvwxyz';\nconst UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst CHARSETS: Record<RandomStringMode, string> = {\n    'alphabetic': LOWERCASE + UPPERCASE,\n    'alphanumeric': DIGITS + LOWERCASE + UPPERCASE,\n    'lowercase': LOWERCASE,\n    'lowercase-numeric': DIGITS + LOWERCASE,\n    'numeric': DIGITS,\n    'uppercase': UPPERCASE,\n    'uppercase-numeric': DIGITS + UPPERCASE,\n};\n\n/**\n * Generates a random string of a given length using a specified character set.\n *\n * @param {number} length - The length of the string to generate. Must be a positive integer\n * @param {RandomStringMode} [mode] - The character set to use\n *\n * @returns {string} The generated random string\n *\n * @throws {Error} If the length is not a positive integer or the mode is unsupported\n *\n * @example\n * ```typescript\n * import { randomString } from '@kikiutils/shared/string';\n *\n * console.log(randomString(8)); // e.g. 'aZbXwTyQ' (alphabetic)\n * console.log(randomString(6, 'numeric')); // e.g. '402398'\n * console.log(randomString(10, 'alphanumeric')); // e.g. 'a9Z4pQ8xY2'\n * ```\n */\nexport function randomString(length: number, mode: RandomStringMode = 'alphabetic') {\n    if (!Number.isInteger(length) || length <= 0) {\n        throw new Error(`Invalid length: ${length}. Must be a positive integer`);\n    }\n\n    const charset = CHARSETS[mode];\n    if (!charset) throw new Error(`Unsupported mode: ${mode}`);\n    return Array.from({ length }, () => charset[Math.floor(Math.random() * charset.length)]).join('');\n}\n"],"mappings":";AASA,MAAM,SAAS;AACf,MAAM,YAAY;AAClB,MAAM,YAAY;AAClB,MAAMA,WAA6C;CAC/C,cAAc,YAAY;CAC1B,gBAAgB,SAAS,YAAY;CACrC,aAAa;CACb,qBAAqB,SAAS;CAC9B,WAAW;CACX,aAAa;CACb,qBAAqB,SAAS;CACjC;;;;;;;;;;;;;;;;;;;;AAqBD,SAAgB,aAAa,QAAgB,OAAyB,cAAc;AAChF,KAAI,CAAC,OAAO,UAAU,OAAO,IAAI,UAAU,EACvC,OAAM,IAAI,MAAM,mBAAmB,OAAO,8BAA8B;CAG5E,MAAM,UAAU,SAAS;AACzB,KAAI,CAAC,QAAS,OAAM,IAAI,MAAM,qBAAqB,OAAO;AAC1D,QAAO,MAAM,KAAK,EAAE,QAAQ,QAAQ,QAAQ,KAAK,MAAM,KAAK,QAAQ,GAAG,QAAQ,OAAO,EAAE,CAAC,KAAK,GAAG"}
+{"version":3,"file":"string.js","names":[],"sources":["../src/string.ts"],"sourcesContent":["export type RandomStringMode =\n  | 'alphabetic'\n  | 'alphanumeric'\n  | 'lowercase'\n  | 'lowercase-numeric'\n  | 'numeric'\n  | 'uppercase'\n  | 'uppercase-numeric';\n\nconst DIGITS = '0123456789';\nconst LOWERCASE = 'abcdefghijklmnopqrstuvwxyz';\nconst UPPERCASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';\nconst CHARSETS: Record<RandomStringMode, string> = {\n    'alphabetic': LOWERCASE + UPPERCASE,\n    'alphanumeric': DIGITS + LOWERCASE + UPPERCASE,\n    'lowercase': LOWERCASE,\n    'lowercase-numeric': DIGITS + LOWERCASE,\n    'numeric': DIGITS,\n    'uppercase': UPPERCASE,\n    'uppercase-numeric': DIGITS + UPPERCASE,\n};\n\n/**\n * Generates a random string of a given length using a specified character set.\n *\n * @param {number} length - The length of the string to generate. Must be a positive integer\n * @param {RandomStringMode} [mode] - The character set to use\n *\n * @returns {string} The generated random string\n *\n * @throws {Error} If the length is not a positive integer or the mode is unsupported\n *\n * @example\n * ```typescript\n * import { randomString } from '@kikiutils/shared/string';\n *\n * console.log(randomString(8)); // e.g. 'aZbXwTyQ' (alphabetic)\n * console.log(randomString(6, 'numeric')); // e.g. '402398'\n * console.log(randomString(10, 'alphanumeric')); // e.g. 'a9Z4pQ8xY2'\n * ```\n */\nexport function randomString(length: number, mode: RandomStringMode = 'alphabetic') {\n    if (!Number.isInteger(length) || length <= 0) {\n        throw new Error(`Invalid length: ${length}. Must be a positive integer`);\n    }\n\n    const charset = CHARSETS[mode];\n    if (!charset) throw new Error(`Unsupported mode: ${mode}`);\n    return Array.from({ length }, () => charset[Math.floor(Math.random() * charset.length)]).join('');\n}\n"],"mappings":";AASA,MAAM,SAAS;AACf,MAAM,YAAY;AAClB,MAAM,YAAY;AAClB,MAAM,WAA6C;CAC/C,cAAc,YAAY;CAC1B,gBAAgB,SAAS,YAAY;CACrC,aAAa;CACb,qBAAqB,SAAS;CAC9B,WAAW;CACX,aAAa;CACb,qBAAqB,SAAS;CACjC;;;;;;;;;;;;;;;;;;;;AAqBD,SAAgB,aAAa,QAAgB,OAAyB,cAAc;AAChF,KAAI,CAAC,OAAO,UAAU,OAAO,IAAI,UAAU,EACvC,OAAM,IAAI,MAAM,mBAAmB,OAAO,8BAA8B;CAG5E,MAAM,UAAU,SAAS;AACzB,KAAI,CAAC,QAAS,OAAM,IAAI,MAAM,qBAAqB,OAAO;AAC1D,QAAO,MAAM,KAAK,EAAE,QAAQ,QAAQ,QAAQ,KAAK,MAAM,KAAK,QAAQ,GAAG,QAAQ,OAAO,EAAE,CAAC,KAAK,GAAG"}

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@ import { Blob as Blob$1, Buffer, File as File$1 } from "node:buffer";
 
 //#region src/types/index.d.ts
 type AnyRecord = Record<string, any>;
-type BinaryInput = Blob | Buffer | File | Blob$1 | File$1;
+type BinaryInput = ArrayBuffer | Blob | Buffer | File | Blob$1 | File$1 | Uint8Array;
 type Booleanish = 'false' | 'true' | boolean;
 type MaybePartial<T> = Partial<T> | T;
 type MaybeReadonly<T> = Readonly<T> | T;

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;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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":";;;;KAQY,SAAA,GAAY;KACZ,WAAA,GAAc,cAAc,OAAO,SAAS,OAAO,SAAW,SAAW;AADzE,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;AAAc,KAI5B,QAJ4B,CAAA,CAAA,CAAA,GAAA,IAAA,GAIP,CAJO;AAAO,KAKnC,SAAA,GALmC,MAAA,GAAA,MAAA;AAAS,KAM5C,aAN4C,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAMJ,OANI,CAMI,MANJ,CAMW,CANX,EAMc,CANd,CAAA,CAAA;AAAO,KAOnD,qBAPmD,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAOH,QAPG,CAOM,aAPN,CAOoB,CAPpB,EAOuB,CAPvB,CAAA,CAAA;AAAW,KAQ9D,cAR8D,CAAA,UAAA,MAAA,GAAA,EAAA,CAAA,CAAA,GAQrB,QARqB,CAQZ,MARY,CAQL,CARK,EAQF,CARE,CAAA,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kikiutils/shared",
   "type": "module",
-  "version": "14.0.1",
+  "version": "14.1.1",
   "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",
@@ -33,7 +33,6 @@
   ],
   "sideEffects": false,
   "exports": {
-    "./*": "./dist/*.js",
     "./package.json": "./package.json",
     "./types": {
       "types": "./dist/types/index.d.ts",
@@ -44,7 +43,8 @@
       "types": null,
       "import": null,
       "require": null
-    }
+    },
+    "./*": "./dist/*.js"
   },
   "files": [
     "./dist",
@@ -67,26 +67,25 @@
     "unused-exports": "ts-unused-exports ./tsconfig.json"
   },
   "peerDependencies": {
-    "@noble/hashes": "^2.0.0",
+    "@noble/hashes": "^2.0.1",
     "@types/fs-extra": "^11.0.4",
     "@types/jsonfile": "^6.1.4",
-    "@types/node": ">= 24",
     "@types/ssh2": "^1.15.5",
     "async-validator": "^4.2.5",
-    "bson": "^7.0.0",
+    "bson": "^7.1.1",
     "consola": "^3.4.2",
     "date-fns": "^4.1.0",
     "decimal.js": "^10.6.0",
-    "element-plus": "^2.11.3",
-    "fs-extra": "^11.3.2",
+    "element-plus": "^2.13.1",
+    "fs-extra": "^11.3.3",
     "lru-cache": "^11.2.4",
     "millify": "^6.1.0",
-    "msgpackr": "^1.11.5",
+    "msgpackr": "^1.11.8",
     "node-ssh": "^13.2.1",
-    "pino": "^10.0.0",
-    "pino-pretty": "^13.1.1",
-    "vue": "^3.5.21",
-    "vue-router": "^4.5.1"
+    "pino": "^10.2.0",
+    "pino-pretty": "^13.1.3",
+    "vue": "^3.5.26",
+    "vue-router": "^4.6.4"
   },
   "peerDependenciesMeta": {
     "@noble/hashes": {
@@ -98,9 +97,6 @@
     "@types/jsonfile": {
       "optional": true
     },
-    "@types/node": {
-      "optional": true
-    },
     "@types/ssh2": {
       "optional": true
     },
@@ -151,38 +147,38 @@
     }
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.7.3",
-    "@kikiutils/eslint-config": "^5.0.0",
+    "@antfu/eslint-config": "^7.0.1",
+    "@kikiutils/eslint-config": "^5.0.2",
     "@kikiutils/tsconfigs": "^5.0.5",
     "@noble/hashes": "^2.0.1",
     "@types/fs-extra": "^11.0.4",
     "@types/jsonfile": "^6.1.4",
-    "@types/node": "^25.0.3",
+    "@types/node": "^25.0.9",
     "@types/ssh2": "^1.15.5",
-    "@vitest/coverage-v8": "^4.0.16",
+    "@vitest/coverage-v8": "^4.0.17",
     "async-validator": "^4.2.5",
-    "bson": "^7.0.0",
+    "bson": "^7.1.1",
     "changelogen": "^0.6.2",
     "consola": "^3.4.2",
     "cross-env": "^10.1.0",
     "date-fns": "^4.1.0",
     "decimal.js": "^10.6.0",
     "depcheck": "^1.4.7",
-    "element-plus": "^2.13.0",
+    "element-plus": "^2.13.1",
     "fs-extra": "^11.3.3",
-    "jsdom": "^27.3.0",
+    "jsdom": "^27.4.0",
     "lru-cache": "^11.2.4",
     "millify": "^6.1.0",
     "msgpackr": "^1.11.8",
     "node-ssh": "^13.2.1",
-    "pino": "^10.1.0",
+    "pino": "^10.2.0",
     "pino-pretty": "^13.1.3",
     "publint": "^0.3.16",
     "ts-unused-exports": "^11.0.1",
-    "tsdown": "^0.18.3",
+    "tsdown": "^0.19.0",
     "typescript": "^5.9.3",
     "unplugin-unused": "^0.5.6",
-    "vitest": "^4.0.16",
+    "vitest": "^4.0.17",
     "vue": "^3.5.26",
     "vue-router": "^4.6.4"
   },

package/src/buffer.ts

@@ -3,37 +3,40 @@ import { Buffer } from 'node:buffer';
 import type { BinaryInput } from './types';
 
 /**
- * Converts a Blob, Buffer, or File to a Buffer.
+ * Converts various binary data types to a Node.js Buffer.
  *
- * This function provides a unified way to convert various binary data types
- * to Node.js Buffer. If the input is already a Buffer, it returns it as-is.
- * For Blob or File inputs, it converts them to Buffer via ArrayBuffer.
+ * This function provides a unified, efficient way to convert different binary formats
+ * (Blob, Buffer, File, ArrayBuffer, or Uint8Array) into a Node.js Buffer.
+ * It prioritizes zero-copy conversions for TypedArrays and ArrayBuffers to ensure
+ * optimal performance.
  *
- * @param {Blob | Buffer | File} input - The input to convert to Buffer
+ * @param {ArrayBuffer | Blob | Buffer | File | Uint8Array} input - The binary data input to convert.
+ * Supports Blob, Buffer, File, ArrayBuffer, and Uint8Array.
  *
- * @returns {Promise<Buffer>} A Promise that resolves to a Buffer
+ * @returns {Promise<Buffer>} A promise that resolves to a Node.js Buffer.
  *
  * @example
  * ```typescript
- * import { toBuffer } from '@kikiutils/shared/general';
+ * import { toBuffer } from '@kikiutils/shared/buffer';
  *
- * // Convert a Buffer (returns as-is)
- * const buffer = Buffer.from('Hello World');
- * const result1 = await toBuffer(buffer);
- * console.log(result1); // <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>
+ * // From ArrayBuffer
+ * const ab = new ArrayBuffer(8);
+ * const bufferFromAB = await toBuffer(ab);
  *
- * // Convert a Blob
- * const blob = new Blob(['Hello from Blob'], { type: 'text/plain' });
- * const result2 = await toBuffer(blob);
- * console.log(result2.toString()); // 'Hello from Blob'
+ * // From Uint8Array (Zero-copy)
+ * const u8 = new Uint8Array([10, 20, 30]);
+ * const bufferFromU8 = await toBuffer(u8);
  *
- * // Convert a File
- * const file = new File(['File content'], 'test.txt', { type: 'text/plain' });
- * const result3 = await toBuffer(file);
- * console.log(result3.toString()); // 'File content'
+ * // From Blob or File
+ * const blob = new Blob(['data'], { type: 'text/plain' });
+ * const bufferFromBlob = await toBuffer(blob);
  * ```
  */
 export async function toBuffer(input: BinaryInput) {
     if (Buffer.isBuffer(input)) return input;
-    return Buffer.from(await input.arrayBuffer());
+    if (input instanceof ArrayBuffer) return Buffer.from(input);
+    if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+    if (typeof input.arrayBuffer === 'function') return Buffer.from(await input.arrayBuffer());
+    // eslint-disable-next-line style/max-len
+    throw new TypeError('The provided input is not a supported binary type (Blob, Buffer, File, ArrayBuffer, or Uint8Array).');
 }

package/src/types/index.ts

@@ -7,7 +7,7 @@ import type {
 export type { FilteredKeyPath } from './filtered-key-path';
 
 export type AnyRecord = Record<string, any>;
-export type BinaryInput = Blob | Buffer | File | NodeBlob | NodeFile;
+export type BinaryInput = ArrayBuffer | Blob | Buffer | File | NodeBlob | NodeFile | Uint8Array;
 export type Booleanish = 'false' | 'true' | boolean;
 export type MaybePartial<T> = Partial<T> | T;
 export type MaybeReadonly<T> = Readonly<T> | T;