tiny-essentials 1.28.19 → 1.29.1

package/dist/v1/libs/array/TinyArrayComparator.mjs

@@ -1,31 +1,78 @@
 /**
- * @fileoverview Array comparison utility.
+ * @fileoverview Array comparison utility with deep object diffing capabilities.
  * @module TinyArrayComparator
  */
 /**
- * @template {any} ArrayItem
+ * @template Item
+ * @typedef {Object} HashEntry
+ * @property {Item} item - The original item stored in the map.
+ * @property {string} hash - The calculated hash representing the item's value.
+ */
+// STRUCTURAL TRANSFORMATION & TYPE DERIVATION:
+// Here we remove 'any' and use 'Partial<Item>' and Mapped Types.
+// VSCode/Intellisense will now know exactly which keys exist within 'added', 'deleted', and 'modified',
+// deriving the types directly from the data structure you pass to the class.
+/**
+ * @template Item
+ * @typedef {Object} ObjectDiff
+ * @property {Partial<Item>} added - Properties added in the new object.
+ * @property {Partial<Item>} deleted - Properties removed from the old object.
+ * @property {Partial<{ [K in keyof Item]: { oldValue: Item[K], newValue: Item[K] } }>} modified - Properties that changed value.
+ * @property {Partial<{ [K in keyof Item]: ObjectDiff<Item[K]> }>} nested - Nested differences for nested objects.
+ */
+// ADVANCED PATTERN MATCHING:
+// We use a discriminated union (status) so the IDE knows that 'oldItem' and 'details'
+// only make sense (or are more relevant) in contexts where the change requires it.
+/**
+ * @template Item
+ * @typedef {Object} DiffResult
+ * @property {Item} item - The item that was affected.
+ * @property {Item} [oldItem] - The original item before the change (only for 'edited' status).
+ * @property {'added'|'deleted'|'edited'} status - The nature of the change.
+ * @property {ObjectDiff<Item>} [details] - Detailed property changes (only if status is 'edited' and deepComparison is enabled).
+ */
+/**
+ * @template Item
  * @typedef {Object} InternalState
  * Holds the internal tracking variables during the comparison process.
- * @property {Map<string, ArrayItem>} oldItemsMap - A map storing the hash as the key and the original item as the value.
- * @property {AffectedItems<ArrayItem>} affectedItems - The final array that collects added or deleted items.
+ * @property {Map<string|number, HashEntry<Item>>} oldItemsMap - A map storing the identity key as the key and the hash entry as the value.
+ * @property {Array<DiffResult<Item>>} affectedItems - The final array that collects added, deleted, or edited items.
  */
 /**
- * The final array that collects added or deleted items.
- * @template {any} ArrayItem
- * @typedef {Array<{item: ArrayItem, status: 'added'|'deleted'}>} AffectedItems
+ * The final array that collects added, deleted, or edited items.
+ * @template Item
+ * @typedef {Array<DiffResult<Item>>} AffectedItems
+ */
+// ZERO-REDUNDANCY RULE:
+// If 'Item' is a known object, 'idKey' will suggest the valid keys of that object (keyof Item).
+// The '(string & {})' is an advanced trick to allow the user to type other strings if the base type is dynamic,
+// without losing autocomplete for the known keys.
+/**
+ * Options to configure the comparator.
+ * @template Item
+ * @typedef {Object} ComparatorOptions
+ * @property {keyof Item | (string & {})} [idKey='id'] - The property name used as a unique identifier for objects to detect edits.
+ * @property {boolean} [deepComparison=true] - If true, provides detailed property-level diffs for edited objects.
  */
 /**
- * Compares two arrays efficiently by hashing their items to detect additions and deletions.
+ * Compares two arrays efficiently by hashing their items to detect additions, deletions, and edits.
  * @template {any} ArrayItem
  */
 class TinyArrayComparator {
     /**
      * Generates a simple 32-bit integer hash converted to a base36 string.
-     * @param {any} item - The item to be hashed (can be an object, array, string, or number).
+     * @param {any} item - The item to be hashed.
      * @returns {string} The unique hash representing the item's value.
+     * @throws {TypeError} Throws a TypeError if the item cannot be stringified due to circular references.
      */
     static generateHash(item) {
-        const stringified = typeof item === 'object' ? JSON.stringify(item) : String(item);
+        let stringified;
+        try {
+            stringified = typeof item === 'object' && item !== null ? JSON.stringify(item) : String(item);
+        }
+        catch (error) {
+            throw new TypeError('Failed to stringify item for hashing. Ensure the object does not have circular references.');
+        }
         let hash = 0;
         for (let i = 0, len = stringified.length; i < len; i++) {
             const char = stringified.charCodeAt(i);
@@ -39,6 +86,49 @@ class TinyArrayComparator {
      * @type {ArrayItem[]}
      */
     #oldArray = [];
+    /**
+     * The key used to track identity of an object (e.g., 'id', 'uuid').
+     * @type {string|null}
+     */
+    #idKey = null;
+    /**
+     * Detects whether deep comparison is enabled.
+     * @type {boolean}
+     */
+    #deepComparison = true;
+    /**
+     * Gets the current identity key.
+     * @returns {string|null}
+     */
+    get idKey() {
+        return this.#idKey;
+    }
+    /**
+     * Sets the identity key used for object comparison.
+     * @param {string|null} value - The property name to use as an identifier.
+     * @throws {TypeError} Throws a TypeError if the value is not a string.
+     */
+    set idKey(value) {
+        if (value !== null && typeof value !== 'string')
+            throw new TypeError('The idKey must be a string or null.');
+        this.#idKey = value;
+    }
+    /**
+     * Gets whether deep comparison is enabled.
+     * @returns {boolean}
+     */
+    get deepComparison() {
+        return this.#deepComparison;
+    }
+    /**
+     * Sets whether deep comparison is enabled.
+     * @param {boolean} value - The configuration value.
+     */
+    set deepComparison(value) {
+        if (typeof value !== 'boolean')
+            throw new TypeError('The deepComparison option must be a boolean.');
+        this.#deepComparison = value;
+    }
     /**
      * Gets the current base array used for comparisons.
      * @returns {ArrayItem[]} The current initial state of the array.
@@ -57,16 +147,23 @@ class TinyArrayComparator {
         this.#oldArray = oldArray;
     }
     /**
-     * Initializes the comparator with an optional base array.
+     * Initializes the comparator with an optional base array and options.
      * @param {ArrayItem[]} [oldArray] - The initial state of the array to be stored.
+     * @param {ComparatorOptions<ArrayItem>} [options={}] - Configuration options for the comparator.
      */
-    constructor(oldArray) {
+    constructor(oldArray, options = {}) {
         if (typeof oldArray !== 'undefined')
             this.oldArray = oldArray;
+        if (typeof options.idKey === 'string') {
+            this.idKey = options.idKey;
+        }
+        if (typeof options.deepComparison === 'boolean') {
+            this.deepComparison = options.deepComparison;
+        }
     }
     /**
      * Proxy to generates a hash converted to a string.
-     * @param {ArrayItem} item - The item to be hashed (can be an object, array, string, or number).
+     * @param {ArrayItem} item - The item to be hashed.
      * @returns {string} The unique hash representing the item's value.
      * @private
      */
@@ -74,7 +171,65 @@ class TinyArrayComparator {
         return TinyArrayComparator.generateHash(item);
     }
     /**
-     * Compares the stored older array with a newer array and identifies missing or new items.
+     * Recursively compares two objects to find differences.
+     * @param {Object} oldObj - The original object.
+     * @param {Object} newObj - The modified object.
+     * @returns {ObjectDiff<ArrayItem>} A structured object containing the differences.
+     */
+    #getDeepDiff(oldObj, newObj) {
+        /** @type {ObjectDiff<ArrayItem>} */
+        const diff = {
+            added: {},
+            deleted: {},
+            modified: {},
+            nested: {},
+        };
+        const allKeys = new Set([...Object.keys(oldObj), ...Object.keys(newObj)]);
+        for (const key of allKeys) {
+            // @ts-ignore
+            const oldVal = oldObj[key];
+            // @ts-ignore
+            const newVal = newObj[key];
+            if (!(key in oldObj)) {
+                // Key exists in new object but not in old
+                // @ts-ignore
+                diff.added[key] = newVal;
+            }
+            else if (!(key in newObj)) {
+                // Key exists in old object but not in new
+                // @ts-ignore
+                diff.deleted[key] = oldVal;
+            }
+            else if (typeof oldVal === 'object' &&
+                oldVal !== null &&
+                typeof newVal === 'object' &&
+                newVal !== null &&
+                !Array.isArray(oldVal) &&
+                !Array.isArray(newObj)) {
+                // Both are objects, recurse
+                const nestedDiff = this.#getDeepDiff(oldVal, newVal);
+                // Only add nested if it actually contains differences
+                if (Object.keys(nestedDiff.added).length > 0 ||
+                    Object.keys(nestedDiff.deleted).length > 0 ||
+                    Object.keys(nestedDiff.modified).length > 0 ||
+                    Object.keys(nestedDiff.nested).length > 0) {
+                    // @ts-ignore
+                    diff.nested[key] = nestedDiff;
+                }
+            }
+            else if (oldVal !== newVal) {
+                // Values are different and not objects (or one is an array)
+                // @ts-ignore
+                diff.modified[key] = {
+                    oldValue: oldVal,
+                    newValue: newVal,
+                };
+            }
+        }
+        return diff;
+    }
+    /**
+     * Compares the stored older array with a newer array and identifies added, deleted, or edited items.
      *
      * @param {ArrayItem[]} newArray - The modified state of the array.
      * @returns {AffectedItems<ArrayItem>} An array containing the affected items and their status.
@@ -90,24 +245,55 @@ class TinyArrayComparator {
         };
         // Step 1: Hash and store all items from the first array
         for (const item of this.#oldArray) {
-            const hashKey = this._generateHash(item);
-            state.oldItemsMap.set(hashKey, item);
+            const hash = this._generateHash(item);
+            // Identity is determined by the idKey. Otherwise, it relies purely on the hash.
+            const identityKey = this.#idKey !== null && item !== null && typeof item === 'object' && this.#idKey in item
+                ? // @ts-ignore
+                    item[this.#idKey]
+                : hash;
+            state.oldItemsMap.set(identityKey, { item, hash });
         }
-        // Step 2: Iterate through the second array to find matches or additions
+        // Step 2: Iterate through the second array to find matches, edits or additions
         for (const item of newArray) {
-            const hashKey = this._generateHash(item);
-            if (state.oldItemsMap.has(hashKey)) {
-                // Item exists in both, so it is unchanged. Remove from map.
-                state.oldItemsMap.delete(hashKey);
+            const hash = this._generateHash(item);
+            const identityKey = this.#idKey !== null && item !== null && typeof item === 'object' && this.#idKey in item
+                ? // @ts-ignore
+                    item[this.#idKey]
+                : hash;
+            const oldData = state.oldItemsMap.get(identityKey);
+            if (oldData) {
+                if (oldData.hash === hash) {
+                    // Item exists and the content is identical. Unchanged.
+                    state.oldItemsMap.delete(identityKey);
+                }
+                else {
+                    // Item has the same identity but a different hash. It was edited.
+                    /** @type {DiffResult<ArrayItem>} */
+                    const diffResult = {
+                        item: item,
+                        oldItem: oldData.item,
+                        status: 'edited',
+                    };
+                    // Perform deep comparison if enabled and items are objects
+                    if (this.#deepComparison &&
+                        typeof item === 'object' &&
+                        item !== null &&
+                        typeof oldData.item === 'object' &&
+                        oldData.item !== null) {
+                        diffResult.details = this.#getDeepDiff(oldData.item, item);
+                    }
+                    state.affectedItems.push(diffResult);
+                    state.oldItemsMap.delete(identityKey);
+                }
             }
             else {
-                // Item was not in the old array, so it is an addition.
+                // Item identity was not found in the old array. It is an addition.
                 state.affectedItems.push({ item, status: 'added' });
             }
         }
         // Step 3: Any item left in the oldItemsMap was not present in the new array (deleted)
-        for (const item of state.oldItemsMap.values()) {
-            state.affectedItems.push({ item, status: 'deleted' });
+        for (const oldData of state.oldItemsMap.values()) {
+            state.affectedItems.push({ item: oldData.item, status: 'deleted' });
         }
         return state.affectedItems;
     }

package/dist/v1/libs/fs/constants.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+/**
+ * @file Numeric constants shared by every {@link TinyFSCore} backend.
+ */
+
+/** @type {Readonly<Record<string, number>>} */
+const constants = Object.freeze({
+  F_OK: 0,
+  R_OK: 4,
+  W_OK: 2,
+  X_OK: 1,
+  COPYFILE_EXCL: 1,
+  COPYFILE_FICLONE: 2,
+  COPYFILE_FICLONE_FORCE: 4,
+  O_RDONLY: 0,
+  O_WRONLY: 1,
+  O_RDWR: 2,
+  O_CREAT: 64,
+  O_EXCL: 128,
+  O_TRUNC: 512,
+  O_APPEND: 1024,
+});
+
+/** @type {Readonly<Record<string, number>>} */
+const PERMISSION = Object.freeze({
+  OWNER_READ: 0o400,
+  OWNER_WRITE: 0o200,
+  OWNER_EXECUTE: 0o100,
+  GROUP_READ: 0o040,
+  GROUP_WRITE: 0o020,
+  GROUP_EXECUTE: 0o010,
+  OTHER_READ: 0o004,
+  OTHER_WRITE: 0o002,
+  OTHER_EXECUTE: 0o001,
+  SETUID: 0o4000,
+  SETGID: 0o2000,
+  STICKY: 0o1000,
+});
+
+/** @type {Readonly<Record<string, number>>} */
+const FILE_TYPE = Object.freeze({
+  FILE: 0o100000,
+  DIRECTORY: 0o040000,
+  SYMBOLIC_LINK: 0o120000,
+});
+
+/** @type {number} */
+const DEFAULT_FILE_MODE = 0o666;
+
+/** @type {number} */
+const DEFAULT_DIRECTORY_MODE = 0o777;
+
+/** @type {number} */
+const DEFAULT_UMASK = 0o022;
+
+/** @type {string} */
+const ROOT_PATH = '/';
+
+/** @type {string} */
+const PATH_SEPARATOR = '/';
+
+/** @type {readonly string[]} */
+const SUPPORTED_ENCODINGS = Object.freeze(['utf8', 'utf-8', 'base64', 'hex']);
+
+exports.DEFAULT_DIRECTORY_MODE = DEFAULT_DIRECTORY_MODE;
+exports.DEFAULT_FILE_MODE = DEFAULT_FILE_MODE;
+exports.DEFAULT_UMASK = DEFAULT_UMASK;
+exports.FILE_TYPE = FILE_TYPE;
+exports.PATH_SEPARATOR = PATH_SEPARATOR;
+exports.PERMISSION = PERMISSION;
+exports.ROOT_PATH = ROOT_PATH;
+exports.SUPPORTED_ENCODINGS = SUPPORTED_ENCODINGS;
+exports.constants = constants;

package/dist/v1/libs/fs/constants.d.mts

@@ -0,0 +1,22 @@
+/**
+ * @file Numeric constants shared by every {@link TinyFSCore} backend.
+ */
+/** @type {Readonly<Record<string, number>>} */
+export declare const constants: Readonly<Record<string, number>>;
+/** @type {Readonly<Record<string, number>>} */
+export declare const PERMISSION: Readonly<Record<string, number>>;
+/** @type {Readonly<Record<string, number>>} */
+export declare const FILE_TYPE: Readonly<Record<string, number>>;
+/** @type {number} */
+export declare const DEFAULT_FILE_MODE: number;
+/** @type {number} */
+export declare const DEFAULT_DIRECTORY_MODE: number;
+/** @type {number} */
+export declare const DEFAULT_UMASK: number;
+/** @type {string} */
+export declare const ROOT_PATH: string;
+/** @type {string} */
+export declare const PATH_SEPARATOR: string;
+/** @type {readonly string[]} */
+export declare const SUPPORTED_ENCODINGS: readonly string[];
+//# sourceMappingURL=constants.d.mts.map

package/dist/v1/libs/fs/constants.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.mts","sourceRoot":"","sources":["../../../../src/v1/libs/fs/constants.mjs"],"names":[],"mappings":"AAAA;;GAEG;AAEH,+CAA+C;AAC/C,eAAO,MAAM,SAAS,EADX,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBxC,CAAC;AAEH,+CAA+C;AAC/C,eAAO,MAAM,UAAU,EADZ,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAcxC,CAAC;AAEH,+CAA+C;AAC/C,eAAO,MAAM,SAAS,EADX,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAKxC,CAAC;AAEH,qBAAqB;AACrB,eAAO,MAAM,iBAAiB,EADnB,MAC2B,CAAC;AAEvC,qBAAqB;AACrB,eAAO,MAAM,sBAAsB,EADxB,MACgC,CAAC;AAE5C,qBAAqB;AACrB,eAAO,MAAM,aAAa,EADf,MACuB,CAAC;AAEnC,qBAAqB;AACrB,eAAO,MAAM,SAAS,EADX,MACiB,CAAC;AAE7B,qBAAqB;AACrB,eAAO,MAAM,cAAc,EADhB,MACsB,CAAC;AAElC,gCAAgC;AAChC,eAAO,MAAM,mBAAmB,EADrB,SAAS,MAAM,EAC0D,CAAC"}

package/dist/v1/libs/fs/constants.mjs

@@ -0,0 +1,53 @@
+/**
+ * @file Numeric constants shared by every {@link TinyFSCore} backend.
+ */
+/** @type {Readonly<Record<string, number>>} */
+export const constants = Object.freeze({
+    F_OK: 0,
+    R_OK: 4,
+    W_OK: 2,
+    X_OK: 1,
+    COPYFILE_EXCL: 1,
+    COPYFILE_FICLONE: 2,
+    COPYFILE_FICLONE_FORCE: 4,
+    O_RDONLY: 0,
+    O_WRONLY: 1,
+    O_RDWR: 2,
+    O_CREAT: 64,
+    O_EXCL: 128,
+    O_TRUNC: 512,
+    O_APPEND: 1024,
+});
+/** @type {Readonly<Record<string, number>>} */
+export const PERMISSION = Object.freeze({
+    OWNER_READ: 0o400,
+    OWNER_WRITE: 0o200,
+    OWNER_EXECUTE: 0o100,
+    GROUP_READ: 0o040,
+    GROUP_WRITE: 0o020,
+    GROUP_EXECUTE: 0o010,
+    OTHER_READ: 0o004,
+    OTHER_WRITE: 0o002,
+    OTHER_EXECUTE: 0o001,
+    SETUID: 0o4000,
+    SETGID: 0o2000,
+    STICKY: 0o1000,
+});
+/** @type {Readonly<Record<string, number>>} */
+export const FILE_TYPE = Object.freeze({
+    FILE: 0o100000,
+    DIRECTORY: 0o040000,
+    SYMBOLIC_LINK: 0o120000,
+});
+/** @type {number} */
+export const DEFAULT_FILE_MODE = 0o666;
+/** @type {number} */
+export const DEFAULT_DIRECTORY_MODE = 0o777;
+/** @type {number} */
+export const DEFAULT_UMASK = 0o022;
+/** @type {string} */
+export const ROOT_PATH = '/';
+/** @type {string} */
+export const PATH_SEPARATOR = '/';
+/** @type {readonly string[]} */
+export const SUPPORTED_ENCODINGS = Object.freeze(['utf8', 'utf-8', 'base64', 'hex']);

package/dist/v1/libs/fs/encoding.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+/**
+ * @file Byte/string conversion helpers shared by every {@link TinyFSCore} backend.
+ */
+
+/**
+ * Converts a byte array into a base64 string.
+ *
+ * @param {Uint8Array} bytes Source bytes.
+ * @returns {string} The base64 representation.
+ */
+const bytesToBase64 = (bytes) => {
+  let binary = '';
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+};
+
+/**
+ * Converts a base64 string into a byte array.
+ *
+ * @param {string} value Source string.
+ * @returns {Uint8Array} The decoded bytes.
+ */
+const base64ToBytes = (value) => {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+};
+
+/**
+ * Converts a byte array into a lowercase hexadecimal string.
+ *
+ * @param {Uint8Array} bytes Source bytes.
+ * @returns {string} The hexadecimal representation.
+ */
+const bytesToHex = (bytes) =>
+  Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+
+/**
+ * Converts a hexadecimal string into a byte array.
+ *
+ * @param {string} value Source string.
+ * @returns {Uint8Array} The decoded bytes.
+ * @throws {TypeError} When the string length is odd.
+ */
+const hexToBytes = (value) => {
+  if (value.length % 2 !== 0) {
+    throw new TypeError('The "hex" encoded string must have an even length');
+  }
+  const bytes = new Uint8Array(value.length / 2);
+  for (let index = 0; index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+};
+
+/**
+ * Decodes a byte array using the requested encoding.
+ *
+ * @param {Uint8Array} bytes Source bytes.
+ * @param {string | null} encoding Target encoding, or `null` for binary.
+ * @returns {string | Uint8Array} The decoded payload.
+ */
+const decodeBytes = (bytes, encoding) => {
+  if (encoding === null) {
+    return bytes;
+  }
+  if (encoding === 'base64') {
+    return bytesToBase64(bytes);
+  }
+  if (encoding === 'hex') {
+    return bytesToHex(bytes);
+  }
+  return new TextDecoder('utf-8').decode(bytes);
+};
+
+/**
+ * Converts supported input values into a byte array.
+ *
+ * @param {string | Uint8Array | ArrayBuffer | ArrayBufferView} data Source payload.
+ * @param {string | null} encoding Encoding used when `data` is a string.
+ * @returns {Uint8Array} The encoded bytes.
+ * @throws {TypeError} When the payload type is not supported.
+ */
+const toUint8Array = (data, encoding) => {
+  if (typeof data === 'string') {
+    if (encoding === 'base64') {
+      return base64ToBytes(data);
+    }
+    if (encoding === 'hex') {
+      return hexToBytes(data);
+    }
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  throw new TypeError('The "data" argument must be a string, an ArrayBuffer or an ArrayBufferView');
+};
+
+exports.base64ToBytes = base64ToBytes;
+exports.bytesToBase64 = bytesToBase64;
+exports.bytesToHex = bytesToHex;
+exports.decodeBytes = decodeBytes;
+exports.hexToBytes = hexToBytes;
+exports.toUint8Array = toUint8Array;

package/dist/v1/libs/fs/encoding.d.mts

@@ -0,0 +1,50 @@
+/**
+ * @file Byte/string conversion helpers shared by every {@link TinyFSCore} backend.
+ */
+/**
+ * Converts a byte array into a base64 string.
+ *
+ * @param {Uint8Array} bytes Source bytes.
+ * @returns {string} The base64 representation.
+ */
+export declare const bytesToBase64: (bytes: Uint8Array) => string;
+/**
+ * Converts a base64 string into a byte array.
+ *
+ * @param {string} value Source string.
+ * @returns {Uint8Array} The decoded bytes.
+ */
+export declare const base64ToBytes: (value: string) => Uint8Array;
+/**
+ * Converts a byte array into a lowercase hexadecimal string.
+ *
+ * @param {Uint8Array} bytes Source bytes.
+ * @returns {string} The hexadecimal representation.
+ */
+export declare const bytesToHex: (bytes: Uint8Array) => string;
+/**
+ * Converts a hexadecimal string into a byte array.
+ *
+ * @param {string} value Source string.
+ * @returns {Uint8Array} The decoded bytes.
+ * @throws {TypeError} When the string length is odd.
+ */
+export declare const hexToBytes: (value: string) => Uint8Array;
+/**
+ * Decodes a byte array using the requested encoding.
+ *
+ * @param {Uint8Array} bytes Source bytes.
+ * @param {string | null} encoding Target encoding, or `null` for binary.
+ * @returns {string | Uint8Array} The decoded payload.
+ */
+export declare const decodeBytes: (bytes: Uint8Array, encoding: string | null) => string | Uint8Array;
+/**
+ * Converts supported input values into a byte array.
+ *
+ * @param {string | Uint8Array | ArrayBuffer | ArrayBufferView} data Source payload.
+ * @param {string | null} encoding Encoding used when `data` is a string.
+ * @returns {Uint8Array} The encoded bytes.
+ * @throws {TypeError} When the payload type is not supported.
+ */
+export declare const toUint8Array: (data: string | Uint8Array | ArrayBuffer | ArrayBufferView, encoding: string | null) => Uint8Array;
+//# sourceMappingURL=encoding.d.mts.map

package/dist/v1/libs/fs/encoding.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.d.mts","sourceRoot":"","sources":["../../../../src/v1/libs/fs/encoding.mjs"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,UAHf,UAAU,KACR,MAQZ,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,UAHf,MAAM,KACJ,UASZ,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,UAHZ,UAAU,KACR,MAG6D,CAAC;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,UAJZ,MAAM,KACJ,UAYZ,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,UAJb,UAAU,YACV,MAAM,GAAG,IAAI,KACX,MAAM,GAAG,UAarB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,SALd,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,eAAe,YACnD,MAAM,GAAG,IAAI,KACX,UAuBZ,CAAC"}