@marcuspuchalla/nachos 0.1.4 → 0.2.0

package/dist/{chunk-UMAX5MX5.js → chunk-EDXZTSIA.js}

@@ -1,10 +1,11 @@
-import { useCborByteString, useCborTextString, INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from './chunk-ZDZ2B5PE.js';
+import { useCborByteString, useCborTextString, INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from './chunk-JESIF5IF.js';
 
 // src/encoder/types.ts
 var DEFAULT_ENCODE_OPTIONS = {
   canonical: false,
   allowIndefinite: true,
   rejectDuplicateKeys: false,
+  mapKeyOrder: "length-first",
   maxDepth: 64,
   maxOutputSize: 100 * 1024 * 1024
   // 100 MB
@@ -40,6 +41,20 @@ function compareBytes(a, b) {
   }
   return 0;
 }
+function compareBytesLexicographic(a, b) {
+  const min = Math.min(a.length, b.length);
+  for (let i = 0; i < min; i++) {
+    const byteA = a[i];
+    const byteB = b[i];
+    if (byteA !== byteB) {
+      return byteA - byteB;
+    }
+  }
+  return a.length - b.length;
+}
+function compareMapKeys(a, b, order = "length-first") {
+  return order === "bytewise" ? compareBytesLexicographic(a, b) : compareBytes(a, b);
+}
 function writeUint(value, bytes) {
   const result = new Uint8Array(bytes);
   for (let i = bytes - 1; i >= 0; i--) {
@@ -350,7 +365,7 @@ function useCborSimpleEncoder(_globalOptions) {
       return true;
     }
     const absValue = Math.abs(value);
-    if (absValue < 6103515625e-14 || absValue > 65504) {
+    if (absValue < 5960464477539063e-23 || absValue > 65504) {
       return false;
     }
     const bytes = encodeFloat16Bytes(value);
@@ -586,7 +601,8 @@ function useCborCollectionEncoder(globalOptions) {
         encodedKey: encodeValue(entry[0], childCtx),
         entry
       }));
-      withEncodedKeys.sort((a, b) => compareBytes(a.encodedKey, b.encodedKey));
+      const keyOrder = ctx.options.mapKeyOrder ?? "length-first";
+      withEncodedKeys.sort((a, b) => compareMapKeys(a.encodedKey, b.encodedKey, keyOrder));
       entries = withEncodedKeys.map((t) => t.entry);
       preEncodedKeys = withEncodedKeys.map((t) => t.encodedKey);
     }
@@ -739,7 +755,19 @@ function useCborEncoder(globalOptions) {
     }
     return result;
   };
+  let currentDepth = 0;
   const encodeValue = (value) => {
+    if (currentDepth > options.maxDepth) {
+      throw new Error(`Maximum nesting depth ${options.maxDepth} exceeded`);
+    }
+    currentDepth++;
+    try {
+      return encodeValueInner(value);
+    } finally {
+      currentDepth--;
+    }
+  };
+  const encodeValueInner = (value) => {
     if (value === null || value === void 0 || typeof value === "boolean") {
       return encodeSimple(value);
     }
@@ -816,5 +844,5 @@ function useCborEncoder(globalOptions) {
 }
 
 export { DEFAULT_ENCODE_OPTIONS, bytesToHex, compareBytes, concatenateUint8Arrays, useCborCollectionEncoder, useCborEncoder, useCborIntegerEncoder, useCborSimpleEncoder, useCborStringEncoder, useCborTagEncoder, writeBigUint, writeUint };
-//# sourceMappingURL=chunk-UMAX5MX5.js.map
-//# sourceMappingURL=chunk-UMAX5MX5.js.map
+//# sourceMappingURL=chunk-EDXZTSIA.js.map
+//# sourceMappingURL=chunk-EDXZTSIA.js.map

package/dist/chunk-EDXZTSIA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/encoder/types.ts","../src/encoder/utils.ts","../src/encoder/composables/useCborIntegerEncoder.ts","../src/encoder/composables/useCborStringEncoder.ts","../src/encoder/composables/useCborSimpleEncoder.ts","../src/encoder/composables/useCborCollectionEncoder.ts","../src/encoder/composables/useCborTagEncoder.ts","../src/encoder/composables/useCborEncoder.ts"],"names":["bytes","textStr"],"mappings":"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","file":"chunk-EDXZTSIA.js","sourcesContent":["/**\n * CBOR Encoder Type Definitions\n * Following RFC 8949 specification\n */\n\nimport type { PlutusConstr, CborByteString, CborTextString, MapKeyOrder } from '../parser/types'\nimport { INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from '../parser/types'\n\n// Re-export symbols and types for use in encoder\nexport { INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL }\nexport type { CborByteString, CborTextString, MapKeyOrder }\n\n/**\n * Encoder options for controlling behavior\n */\nexport interface EncodeOptions {\n  /** Enable canonical encoding (shortest form, sorted maps) */\n  canonical?: boolean\n  /** Allow indefinite-length encoding (false in canonical mode) */\n  allowIndefinite?: boolean\n  /** Reject duplicate map keys */\n  rejectDuplicateKeys?: boolean\n  /**\n   * Map key ordering used in canonical mode.\n   * Defaults to 'length-first' (Cardano CIP-21 / RFC 7049 §3.9).\n   * Use 'bytewise' for RFC 8949 §4.2.1 core deterministic order.\n   */\n  mapKeyOrder?: MapKeyOrder\n  /** Maximum nesting depth */\n  maxDepth?: number\n  /** Maximum output size in bytes */\n  maxOutputSize?: number\n}\n\n/**\n * Default encode options\n */\nexport const DEFAULT_ENCODE_OPTIONS: Required<EncodeOptions> = {\n  canonical: false,\n  allowIndefinite: true,\n  rejectDuplicateKeys: false,\n  mapKeyOrder: 'length-first',\n  maxDepth: 64,\n  maxOutputSize: 100 * 1024 * 1024  // 100 MB\n}\n\n/**\n * Result of encoding operation\n */\nexport interface EncodeResult {\n  /** Encoded CBOR bytes */\n  bytes: Uint8Array\n  /** Hex string representation */\n  hex: string\n}\n\n/**\n * Values that can be encoded to CBOR\n *\n * Supports both plain objects (for convenience) and Maps (for type preservation).\n * Map<any, any> is preferred for maps with non-string keys (integers, Uint8Arrays, etc.)\n */\nexport type EncodableValue =\n  | number\n  | bigint\n  | string\n  | boolean\n  | null\n  | undefined\n  | Uint8Array\n  | EncodableValue[]\n  | { [key: string]: EncodableValue }  // Plain object (legacy/convenience)\n  | Map<EncodableValue, EncodableValue>  // Map (preserves key types)\n  | TaggedValue\n\n/**\n * Tagged CBOR value (Major Type 6)\n */\nexport interface TaggedValue {\n  tag: number\n  value: EncodableValue\n  plutus?: PlutusConstr\n}\n\n/**\n * Encoding context that tracks state during CBOR encoding\n */\nexport interface EncodeContext {\n  /** Current nesting depth */\n  depth: number\n  /** Encoder options */\n  options: Required<EncodeOptions>\n}\n","/**\n * CBOR Encoder Utility Functions\n */\n\n/**\n * Convert Uint8Array to hex string\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  return Array.from(bytes)\n    .map(b => b.toString(16).padStart(2, '0'))\n    .join('')\n}\n\n/**\n * Concatenate multiple Uint8Arrays\n */\nexport function concatenateUint8Arrays(arrays: Uint8Array[]): Uint8Array {\n  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0)\n  const result = new Uint8Array(totalLength)\n\n  let offset = 0\n  for (const arr of arrays) {\n    result.set(arr, offset)\n    offset += arr.length\n  }\n\n  return result\n}\n\n/**\n * Compare two Uint8Arrays length-first (RFC 7049 §3.9 / Cardano CIP-21 ordering).\n * Shorter keys sort first; equal-length keys are compared bytewise.\n */\nexport function compareBytes(a: Uint8Array, b: Uint8Array): number {\n  // First, compare lengths\n  if (a.length !== b.length) {\n    return a.length - b.length\n  }\n\n  // Then, compare bytewise\n  for (let i = 0; i < a.length; i++) {\n    const byteA = a[i]\n    const byteB = b[i]\n    if (byteA === undefined || byteB === undefined) {\n      throw new Error(`Unexpected undefined byte at index ${i}`)\n    }\n    if (byteA !== byteB) {\n      return byteA - byteB\n    }\n  }\n\n  return 0\n}\n\n/**\n * Compare two Uint8Arrays in pure bytewise lexicographic order\n * (RFC 8949 §4.2.1 core deterministic encoding). If one is a prefix of the\n * other, the shorter sorts first.\n */\nexport function compareBytesLexicographic(a: Uint8Array, b: Uint8Array): number {\n  const min = Math.min(a.length, b.length)\n  for (let i = 0; i < min; i++) {\n    const byteA = a[i]!\n    const byteB = b[i]!\n    if (byteA !== byteB) {\n      return byteA - byteB\n    }\n  }\n  return a.length - b.length\n}\n\n/**\n * Compare two encoded map keys according to the requested ordering.\n *\n * @param order - 'length-first' (CIP-21 / RFC 7049 §3.9, default) or\n *                'bytewise' (RFC 8949 §4.2.1 core deterministic)\n */\nexport function compareMapKeys(\n  a: Uint8Array,\n  b: Uint8Array,\n  order: 'length-first' | 'bytewise' = 'length-first'\n): number {\n  return order === 'bytewise' ? compareBytesLexicographic(a, b) : compareBytes(a, b)\n}\n\n/**\n * Write unsigned integer to bytes (big-endian)\n */\nexport function writeUint(value: number, bytes: number): Uint8Array {\n  const result = new Uint8Array(bytes)\n\n  for (let i = bytes - 1; i >= 0; i--) {\n    result[i] = value & 0xff\n    value = value >>> 8\n  }\n\n  return result\n}\n\n/**\n * Write BigInt to bytes (big-endian)\n */\nexport function writeBigUint(value: bigint, bytes: number): Uint8Array {\n  const result = new Uint8Array(bytes)\n\n  for (let i = bytes - 1; i >= 0; i--) {\n    result[i] = Number(value & 0xffn)\n    value = value >> 8n\n  }\n\n  return result\n}\n","/**\n * CBOR Integer Encoder Composable\n * Handles Major Type 0 (Unsigned) and Major Type 1 (Negative)\n * Following RFC 8949 specification\n */\n\nimport type { EncodeResult } from '../types'\nimport { bytesToHex, writeUint, writeBigUint } from '../utils'\n\n/**\n * CBOR Integer Encoder Composable\n *\n * Provides functions to encode integers to CBOR format:\n * - Major Type 0: Unsigned integers (0 to 2^64-1)\n * - Major Type 1: Negative integers (-1 to -2^64)\n *\n * @example\n * ```ts\n * const { encodeUnsignedInt, encodeNegativeInt, encodeInteger } = useCborIntegerEncoder()\n *\n * // Encode unsigned integer\n * const result1 = encodeUnsignedInt(100)\n * // result1: { bytes: Uint8Array([0x18, 0x64]), hex: '1864' }\n *\n * // Encode negative integer\n * const result2 = encodeNegativeInt(-100)\n * // result2: { bytes: Uint8Array([0x38, 0x63]), hex: '3863' }\n *\n * // Auto-detect integer type\n * const result3 = encodeInteger(-100)\n * // result3: { bytes: Uint8Array([0x38, 0x63]), hex: '3863' }\n * ```\n */\nexport function useCborIntegerEncoder() {\n  /**\n   * Encode unsigned integer (Major Type 0)\n   *\n   * Encoding rules:\n   * - 0-23: Direct encoding in initial byte (0x00-0x17)\n   * - 24-255: 0x18 + 1 byte\n   * - 256-65535: 0x19 + 2 bytes\n   * - 65536-4294967295: 0x1a + 4 bytes\n   * - 4294967296-2^64-1: 0x1b + 8 bytes\n   *\n   * @param value - Unsigned integer (0 to 2^64-1)\n   * @returns Encoded CBOR bytes and hex string\n   * @throws Error if value is negative or >= 2^64\n   */\n  const encodeUnsignedInt = (value: number | bigint): EncodeResult => {\n    // Convert to BigInt for consistent handling\n    const bigValue = typeof value === 'bigint' ? value : BigInt(value)\n\n    // Validate value is non-negative\n    if (bigValue < 0n) {\n      throw new Error('Cannot encode negative value as unsigned integer')\n    }\n\n    // Validate value doesn't exceed 2^64-1\n    const MAX_UINT64 = 18446744073709551615n  // 2^64 - 1\n    if (bigValue > MAX_UINT64) {\n      throw new Error('Value exceeds maximum unsigned integer (2^64-1)')\n    }\n\n    let bytes: Uint8Array\n\n    // Direct encoding (0-23)\n    if (bigValue <= 23n) {\n      bytes = new Uint8Array([Number(bigValue)])\n    }\n    // 1-byte encoding (24-255)\n    else if (bigValue <= 255n) {\n      bytes = new Uint8Array([0x18, Number(bigValue)])\n    }\n    // 2-byte encoding (256-65535)\n    else if (bigValue <= 65535n) {\n      const valueBytes = writeUint(Number(bigValue), 2)\n      bytes = new Uint8Array([0x19, ...valueBytes])\n    }\n    // 4-byte encoding (65536-4294967295)\n    else if (bigValue <= 4294967295n) {\n      const valueBytes = writeUint(Number(bigValue), 4)\n      bytes = new Uint8Array([0x1a, ...valueBytes])\n    }\n    // 8-byte encoding (> 4294967295)\n    else {\n      const valueBytes = writeBigUint(bigValue, 8)\n      bytes = new Uint8Array([0x1b, ...valueBytes])\n    }\n\n    return {\n      bytes,\n      hex: bytesToHex(bytes)\n    }\n  }\n\n  /**\n   * Encode negative integer (Major Type 1)\n   *\n   * CBOR encodes negative integers as: -1 - N\n   * where N is the encoded value\n   *\n   * Encoding rules:\n   * - -1 to -24: Direct encoding in initial byte (0x20-0x37)\n   * - -25 to -256: 0x38 + 1 byte\n   * - -257 to -65536: 0x39 + 2 bytes\n   * - -65537 to -4294967296: 0x3a + 4 bytes\n   * - -4294967297 to -2^64: 0x3b + 8 bytes\n   *\n   * @param value - Negative integer (-1 to -2^64)\n   * @returns Encoded CBOR bytes and hex string\n   * @throws Error if value is non-negative or < -2^64\n   */\n  const encodeNegativeInt = (value: number | bigint): EncodeResult => {\n    // Convert to BigInt for consistent handling\n    const bigValue = typeof value === 'bigint' ? value : BigInt(value)\n\n    // Validate value is negative\n    if (bigValue >= 0n) {\n      throw new Error('Cannot encode positive value as negative integer')\n    }\n\n    // Validate value doesn't exceed -2^64\n    const MIN_INT64 = -18446744073709551616n  // -2^64\n    if (bigValue < MIN_INT64) {\n      throw new Error('Value exceeds minimum negative integer (-2^64)')\n    }\n\n    // CBOR encodes negative as: -1 - N\n    // So for value V, we encode N = -1 - V\n    const encoded = -1n - bigValue\n\n    let bytes: Uint8Array\n\n    // Direct encoding (-1 to -24, encoded as 0-23)\n    if (encoded <= 23n) {\n      bytes = new Uint8Array([0x20 + Number(encoded)])\n    }\n    // 1-byte encoding (-25 to -256, encoded as 24-255)\n    else if (encoded <= 255n) {\n      bytes = new Uint8Array([0x38, Number(encoded)])\n    }\n    // 2-byte encoding (-257 to -65536, encoded as 256-65535)\n    else if (encoded <= 65535n) {\n      const valueBytes = writeUint(Number(encoded), 2)\n      bytes = new Uint8Array([0x39, ...valueBytes])\n    }\n    // 4-byte encoding (-65537 to -4294967296, encoded as 65536-4294967295)\n    else if (encoded <= 4294967295n) {\n      const valueBytes = writeUint(Number(encoded), 4)\n      bytes = new Uint8Array([0x3a, ...valueBytes])\n    }\n    // 8-byte encoding (< -4294967296)\n    else {\n      const valueBytes = writeBigUint(encoded, 8)\n      bytes = new Uint8Array([0x3b, ...valueBytes])\n    }\n\n    return {\n      bytes,\n      hex: bytesToHex(bytes)\n    }\n  }\n\n  /**\n   * Encode integer (auto-detect type)\n   *\n   * Automatically selects Major Type 0 (unsigned) or Major Type 1 (negative)\n   * based on the sign of the value.\n   *\n   * @param value - Any integer\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeInteger = (value: number | bigint): EncodeResult => {\n    const bigValue = typeof value === 'bigint' ? value : BigInt(value)\n\n    if (bigValue < 0n) {\n      return encodeNegativeInt(bigValue)\n    } else {\n      return encodeUnsignedInt(bigValue)\n    }\n  }\n\n  return {\n    encodeUnsignedInt,\n    encodeNegativeInt,\n    encodeInteger\n  }\n}\n","/**\n * CBOR String Encoder Composable\n * Handles Major Type 2 (Byte Strings) and Major Type 3 (Text Strings)\n * Following RFC 8949 specification\n */\n\nimport type { EncodeResult, EncodeOptions, CborByteString, CborTextString } from '../types'\nimport { DEFAULT_ENCODE_OPTIONS, INDEFINITE_SYMBOL } from '../types'\nimport { bytesToHex, concatenateUint8Arrays, writeUint, writeBigUint } from '../utils'\nimport { useCborByteString, useCborTextString } from '../../parser/composables/useCborStringTypes'\n\ninterface StringEncodeOptions {\n  indefinite?: boolean\n}\n\n/**\n * CBOR String Encoder Composable\n *\n * Provides functions to encode byte strings and text strings:\n * - Major Type 2: Byte strings (Uint8Array)\n * - Major Type 3: Text strings (UTF-8 encoded)\n *\n * Supports both definite-length and indefinite-length encoding.\n *\n * @param options - Global encoder options\n *\n * @example\n * ```ts\n * const { encodeByteString, encodeTextString } = useCborStringEncoder()\n *\n * // Encode byte string\n * const bytes = new Uint8Array([0x01, 0x02, 0x03])\n * const result1 = encodeByteString(bytes)\n * // result1: { bytes: Uint8Array([0x43, 0x01, 0x02, 0x03]), hex: '43010203' }\n *\n * // Encode text string\n * const result2 = encodeTextString('Hello')\n * // result2: { bytes: Uint8Array([0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6f]), hex: '6548656c6c6f' }\n *\n * // Indefinite-length encoding\n * const chunks = [new Uint8Array([0xaa]), new Uint8Array([0xbb])]\n * const result3 = encodeByteStringIndefinite(chunks)\n * // result3: { bytes: Uint8Array([0x5f, 0x41, 0xaa, 0x41, 0xbb, 0xff]), hex: '5f41aa41bbff' }\n * ```\n */\nexport function useCborStringEncoder(globalOptions?: Partial<EncodeOptions>) {\n  const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions }\n  const { isCborByteString } = useCborByteString()\n  const { isCborTextString } = useCborTextString()\n\n  /**\n   * Encode the length header for a string\n   *\n   * @param majorType - Major type (2 for bytes, 3 for text)\n   * @param length - Length of the string in bytes\n   * @returns Encoded length header\n   */\n  const encodeLengthHeader = (majorType: number, length: number): Uint8Array => {\n    const baseValue = majorType << 5\n\n    // Direct encoding (0-23)\n    if (length <= 23) {\n      return new Uint8Array([baseValue | length])\n    }\n    // 1-byte length (24-255)\n    else if (length <= 255) {\n      return new Uint8Array([baseValue | 24, length])\n    }\n    // 2-byte length (256-65535)\n    else if (length <= 65535) {\n      const lengthBytes = writeUint(length, 2)\n      return new Uint8Array([baseValue | 25, ...lengthBytes])\n    }\n    // 4-byte length (65536-4294967295)\n    else if (length <= 4294967295) {\n      const lengthBytes = writeUint(length, 4)\n      return new Uint8Array([baseValue | 26, ...lengthBytes])\n    }\n    // 8-byte length (> 4294967295)\n    else {\n      const lengthBytes = length > Number.MAX_SAFE_INTEGER\n        ? writeBigUint(BigInt(length), 8)\n        : writeUint(length, 8)\n      return new Uint8Array([baseValue | 27, ...lengthBytes])\n    }\n  }\n\n  /**\n   * Encode byte string (Major Type 2)\n   *\n   * Can encode either:\n   * - Definite-length: Single Uint8Array\n   * - Indefinite-length: Array of Uint8Array chunks (if indefinite option is set)\n   *\n   * @param data - Byte data or array of chunks\n   * @param encodeOptions - Encoding options\n   * @returns Encoded CBOR bytes and hex string\n   * @throws Error if indefinite encoding is used in canonical mode\n   */\n  const encodeByteString = (\n    data: Uint8Array | Uint8Array[] | CborByteString,\n    encodeOptions?: StringEncodeOptions\n  ): EncodeResult => {\n    // Check if it's a CborByteString with indefinite marker\n    const isIndefinite = isCborByteString(data) && (data as any)[INDEFINITE_SYMBOL] === true\n\n    // Handle indefinite-length encoding\n    if (encodeOptions?.indefinite || Array.isArray(data) || isIndefinite) {\n      if (options.allowIndefinite === false) {\n        throw new Error('Indefinite-length encoding is not allowed')\n      }\n      if (options.canonical) {\n        throw new Error('Indefinite-length encoding not allowed in canonical mode')\n      }\n\n      // If it's a CborByteString with chunks, use the original chunks\n      if (isCborByteString(data) && data.chunks) {\n        return encodeByteStringIndefinite(data.chunks)\n      }\n\n      // Otherwise, get the actual bytes and encode as single chunk\n      const bytes = isCborByteString(data) ? data.bytes : (Array.isArray(data) ? data : [data])\n      return encodeByteStringIndefinite(Array.isArray(bytes) ? bytes : [bytes])\n    }\n\n    // Definite-length encoding - extract bytes from CborByteString if needed\n    const bytes = isCborByteString(data) ? data.bytes : (data as Uint8Array)\n\n    // Check size limit before allocating (header is at most 9 bytes)\n    if (bytes.length + 9 > options.maxOutputSize) {\n      throw new Error(`Encoded output exceeds maximum size`)\n    }\n\n    const header = encodeLengthHeader(2, bytes.length)\n    const result = concatenateUint8Arrays([header, bytes])\n\n    return {\n      bytes: result,\n      hex: bytesToHex(result)\n    }\n  }\n\n  /**\n   * Encode byte string with indefinite length (Major Type 2)\n   *\n   * Format: 0x5f + chunk1 + chunk2 + ... + 0xff\n   * Each chunk is a definite-length byte string.\n   *\n   * @param chunks - Array of byte string chunks\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeByteStringIndefinite = (chunks: Uint8Array[]): EncodeResult => {\n    if (options.allowIndefinite === false) {\n      throw new Error('Indefinite-length encoding is not allowed')\n    }\n    if (options.canonical) {\n      throw new Error('Indefinite-length encoding not allowed in canonical mode')\n    }\n\n    const parts: Uint8Array[] = [new Uint8Array([0x5f])]  // Start marker\n\n    // Encode each chunk as definite-length byte string\n    for (const chunk of chunks) {\n      const header = encodeLengthHeader(2, chunk.length)\n      parts.push(header)\n      parts.push(chunk)\n    }\n\n    parts.push(new Uint8Array([0xff]))  // Break marker\n\n    const result = concatenateUint8Arrays(parts)\n\n    return {\n      bytes: result,\n      hex: bytesToHex(result)\n    }\n  }\n\n  /**\n   * Encode text string (Major Type 3)\n   *\n   * Text strings are encoded as UTF-8 bytes.\n   *\n   * @param text - Text string to encode\n   * @param _encodeOptions - Encoding options (reserved for future use)\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeTextString = (\n    text: string | CborTextString,\n    encodeOptions?: StringEncodeOptions\n  ): EncodeResult => {\n    // Check if it's a CborTextString with indefinite marker\n    const isIndefinite = isCborTextString(text) && (text as any)[INDEFINITE_SYMBOL] === true\n\n    // Handle indefinite-length encoding\n    if (encodeOptions?.indefinite || isIndefinite) {\n      if (options.allowIndefinite === false) {\n        throw new Error('Indefinite-length encoding is not allowed')\n      }\n      if (options.canonical) {\n        throw new Error('Indefinite-length encoding not allowed in canonical mode')\n      }\n\n      // If it's a CborTextString with chunks, use the original chunks\n      if (isCborTextString(text) && text.chunks) {\n        return encodeTextStringIndefinite(text.chunks)\n      }\n\n      // Otherwise, get the actual text and encode as single chunk\n      const textStr = isCborTextString(text) ? text.text : text\n      return encodeTextStringIndefinite([textStr])\n    }\n\n    // Definite-length encoding - extract text from CborTextString if needed\n    const textStr = isCborTextString(text) ? text.text : text\n\n    // Convert string to UTF-8 bytes\n    const encoder = new TextEncoder()\n    const utf8Bytes = encoder.encode(textStr)\n\n    // Check size limit before allocating (header is at most 9 bytes)\n    if (utf8Bytes.length + 9 > options.maxOutputSize) {\n      throw new Error(`Encoded output exceeds maximum size`)\n    }\n\n    const header = encodeLengthHeader(3, utf8Bytes.length)\n    const result = concatenateUint8Arrays([header, utf8Bytes])\n\n    return {\n      bytes: result,\n      hex: bytesToHex(result)\n    }\n  }\n\n  /**\n   * Encode text string with indefinite length (Major Type 3)\n   *\n   * Format: 0x7f + chunk1 + chunk2 + ... + 0xff\n   * Each chunk is a definite-length text string.\n   *\n   * @param chunks - Array of text string chunks\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeTextStringIndefinite = (chunks: string[]): EncodeResult => {\n    if (options.allowIndefinite === false) {\n      throw new Error('Indefinite-length encoding is not allowed')\n    }\n    if (options.canonical) {\n      throw new Error('Indefinite-length encoding not allowed in canonical mode')\n    }\n\n    const parts: Uint8Array[] = [new Uint8Array([0x7f])]  // Start marker\n\n    // Encode each chunk as definite-length text string\n    const encoder = new TextEncoder()\n    for (const chunk of chunks) {\n      const utf8Bytes = encoder.encode(chunk)\n      const header = encodeLengthHeader(3, utf8Bytes.length)\n      parts.push(header)\n      parts.push(utf8Bytes)\n    }\n\n    parts.push(new Uint8Array([0xff]))  // Break marker\n\n    const result = concatenateUint8Arrays(parts)\n\n    return {\n      bytes: result,\n      hex: bytesToHex(result)\n    }\n  }\n\n  return {\n    encodeByteString,\n    encodeByteStringIndefinite,\n    encodeTextString,\n    encodeTextStringIndefinite\n  }\n}\n","/**\n * CBOR Simple Values and Floats Encoder Composable\n * Handles Major Type 7 (Floats and Simple Values)\n * Following RFC 8949 specification\n */\n\nimport type { EncodeResult, EncodeOptions } from '../types'\nimport { bytesToHex } from '../utils'\nimport { useCborIntegerEncoder } from './useCborIntegerEncoder'\n\n/**\n * CBOR Simple Values and Floats Encoder Composable\n *\n * Provides functions to encode:\n * - Simple values: false, true, null, undefined\n * - Floating-point numbers: float16, float32, float64\n *\n * @param options - Global encoder options\n *\n * @example\n * ```ts\n * const { encodeSimple, encodeFloat } = useCborSimpleEncoder()\n *\n * // Encode simple values\n * const result1 = encodeSimple(true)\n * // result1: { bytes: Uint8Array([0xf5]), hex: 'f5' }\n *\n * // Encode float\n * const result2 = encodeFloat(1.1)\n * // result2: { bytes: Uint8Array([0xfb, ...]), hex: 'fb...' }\n * ```\n */\nexport function useCborSimpleEncoder(_globalOptions?: Partial<EncodeOptions>) {\n  const { encodeInteger } = useCborIntegerEncoder()\n\n  /**\n   * Encode simple values (booleans, null, undefined)\n   *\n   * @param value - Simple value to encode\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeSimple = (value: boolean | null | undefined): EncodeResult => {\n    let byte: number\n\n    if (value === false) {\n      byte = 0xf4\n    } else if (value === true) {\n      byte = 0xf5\n    } else if (value === null) {\n      byte = 0xf6\n    } else if (value === undefined) {\n      byte = 0xf7\n    } else {\n      throw new Error(`Unsupported simple value: ${value}`)\n    }\n\n    return {\n      bytes: new Uint8Array([byte]),\n      hex: bytesToHex(new Uint8Array([byte]))\n    }\n  }\n\n  /**\n   * Encode float16 (IEEE 754 half precision)\n   *\n   * @param value - Number to encode\n   * @returns Uint8Array with float16 bytes (2 bytes)\n   */\n  const encodeFloat16Bytes = (value: number): Uint8Array => {\n    // Handle special cases\n    if (Object.is(value, -0)) return new Uint8Array([0x80, 0x00])\n    if (value === 0) return new Uint8Array([0x00, 0x00])\n    if (Number.isNaN(value)) return new Uint8Array([0x7e, 0x00])\n    if (value === Infinity) return new Uint8Array([0x7c, 0x00])\n    if (value === -Infinity) return new Uint8Array([0xfc, 0x00])\n\n    // Convert float64 to float16\n    const sign = value < 0 ? 1 : 0\n    const absValue = Math.abs(value)\n\n    // Get exponent and mantissa from float64\n    const buffer = new ArrayBuffer(8)\n    const view = new DataView(buffer)\n    view.setFloat64(0, absValue, false)\n\n    const bits = view.getBigUint64(0, false)\n    const exp64 = Number((bits >> 52n) & 0x7ffn) - 1023\n    const mant64 = Number(bits & 0xfffffffffffffn)\n\n    // Convert to float16 range\n    // Use BigInt for bit manipulation since mant64 can exceed 32 bits,\n    // which would cause JavaScript's bitwise operators to truncate silently.\n    const mant64n = BigInt(mant64)\n    let exp16: number\n    let mant16: number\n\n    if (exp64 < -24) {\n      // Too small even for subnormal float16\n      exp16 = 0\n      mant16 = 0\n    } else if (exp64 < -14) {\n      // Subnormal float16: shift the implicit 1.mantissa into the fraction bits\n      exp16 = 0\n      const shift = -14 - exp64\n      // Build the full subnormal mantissa: implicit 1 bit + top 10 mantissa bits,\n      // then apply IEEE 754 round-half-to-even before shifting into subnormal position.\n      // The 11-bit value (1.mant10) needs to be right-shifted by 'shift' to get the\n      // subnormal mantissa. We apply rounding at the shift boundary.\n      const fullMant = (1n << 10n) | (mant64n >> 42n)\n      // Bits lost from the float64 mantissa during the >> 42 extraction\n      const lostFromExtract = mant64n & ((1n << 42n) - 1n)\n      // The 'shift' additional bits lost when converting to subnormal\n      const shiftN = BigInt(shift)\n      const guardBit = Number((fullMant >> (shiftN - 1n)) & 1n)\n      // Sticky includes bits below guard in fullMant plus any bits lost from extraction\n      const stickyBitsBelow = shiftN > 1n ? (fullMant & ((1n << (shiftN - 1n)) - 1n)) : 0n\n      const sticky = (stickyBitsBelow !== 0n || lostFromExtract !== 0n) ? 1 : 0\n      const truncated = Number(fullMant >> shiftN)\n      const lsb = truncated & 1\n      mant16 = truncated + (guardBit & (sticky | lsb))\n    } else if (exp64 > 15) {\n      // Overflow to infinity\n      exp16 = 31\n      mant16 = 0\n    } else {\n      // Normal number: IEEE 754 round-half-to-even (guard/round/sticky)\n      exp16 = exp64 + 15\n      const truncated = Number(mant64n >> 42n)\n      const guardBit = Number((mant64n >> 41n) & 1n)\n      const stickyBits = (mant64n & ((1n << 41n) - 1n)) !== 0n ? 1 : 0\n      const lsb = truncated & 1  // least significant bit of truncated result\n      mant16 = truncated + (guardBit & (stickyBits | lsb))\n      // Handle mantissa overflow from rounding (0x3FF + 1 = 0x400 bumps exponent)\n      if (mant16 > 0x3ff) {\n        mant16 = 0\n        exp16 += 1\n        // If exp16 overflows to 31 (0x1f), it becomes infinity -- correct IEEE 754 behavior\n      }\n    }\n\n    const float16 = (sign << 15) | (exp16 << 10) | mant16\n\n    return new Uint8Array([\n      (float16 >> 8) & 0xff,\n      float16 & 0xff\n    ])\n  }\n\n  /**\n   * Encode float32 (IEEE 754 single precision)\n   *\n   * @param value - Number to encode\n   * @returns Uint8Array with float32 bytes (4 bytes)\n   */\n  const encodeFloat32Bytes = (value: number): Uint8Array => {\n    const buffer = new ArrayBuffer(4)\n    const view = new DataView(buffer)\n    view.setFloat32(0, value, false)  // Big-endian\n\n    return new Uint8Array(buffer)\n  }\n\n  /**\n   * Encode float64 (IEEE 754 double precision)\n   *\n   * @param value - Number to encode\n   * @returns Uint8Array with float64 bytes (8 bytes)\n   */\n  const encodeFloat64Bytes = (value: number): Uint8Array => {\n    const buffer = new ArrayBuffer(8)\n    const view = new DataView(buffer)\n    view.setFloat64(0, value, false)  // Big-endian\n\n    return new Uint8Array(buffer)\n  }\n\n  /**\n   * Check if a number can be exactly represented as float16\n   *\n   * @param value - Number to check\n   * @returns True if can be represented as float16\n   */\n  const canBeFloat16 = (value: number): boolean => {\n    // Special values\n    if (!Number.isFinite(value) || Object.is(value, 0) || Object.is(value, -0)) {\n      return true\n    }\n\n    // Check range. The lower bound is the smallest positive float16 SUBNORMAL\n    // (2^-24 ≈ 5.96e-8), NOT the smallest normal (2^-14). Using 2^-14 here\n    // previously made the encoder emit float32 for representable subnormals,\n    // producing output its own canonical decoder (fitsInFloat16) then rejected.\n    // The round-trip equality check below is the real precision gate.\n    const absValue = Math.abs(value)\n    if (absValue < 5.960464477539063e-8 || absValue > 65504) {\n      return false\n    }\n\n    // Encode and decode to check for precision loss\n    const bytes = encodeFloat16Bytes(value)\n    const view = new DataView(bytes.buffer)\n    const bits = view.getUint16(0, false)\n\n    const sign = (bits >> 15) & 0x1\n    const exp = (bits >> 10) & 0x1f\n    const mant = bits & 0x3ff\n\n    let decoded: number\n\n    if (exp === 0) {\n      decoded = (sign ? -1 : 1) * Math.pow(2, -14) * (mant / 1024)\n    } else if (exp === 31) {\n      decoded = mant === 0 ? (sign ? -Infinity : Infinity) : NaN\n    } else {\n      decoded = (sign ? -1 : 1) * Math.pow(2, exp - 15) * (1 + mant / 1024)\n    }\n\n    return decoded === value\n  }\n\n  /**\n   * Check if a number can be exactly represented as float32\n   *\n   * @param value - Number to check\n   * @returns True if can be represented as float32\n   */\n  const canBeFloat32 = (value: number): boolean => {\n    // Special values\n    if (!Number.isFinite(value) || Object.is(value, 0) || Object.is(value, -0)) {\n      return true\n    }\n\n    // Encode as float32 and decode back to check for precision loss\n    const buffer = new ArrayBuffer(4)\n    const view = new DataView(buffer)\n    view.setFloat32(0, value, false)\n    const decoded = view.getFloat32(0, false)\n\n    return decoded === value\n  }\n\n  /**\n   * Check if a number is an integer\n   *\n   * @param value - Number to check\n   * @returns True if value is an integer\n   */\n  const isInteger = (value: number): boolean => {\n    return Number.isInteger(value) && Number.isSafeInteger(value)\n  }\n\n  /**\n   * Encode floating-point number\n   *\n   * @param value - Number to encode\n   * @param precision - Optional precision (16, 32, or 64). If not specified, uses smallest possible.\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeFloat = (value: number, precision?: 16 | 32 | 64): EncodeResult => {\n    let bytes: Uint8Array\n\n    // If value is an integer, encode as integer\n    if (isInteger(value) && !precision) {\n      return encodeInteger(value)\n    }\n\n    // If precision is specified, use it\n    if (precision === 16) {\n      const floatBytes = encodeFloat16Bytes(value)\n      bytes = new Uint8Array([0xf9, ...floatBytes])\n    } else if (precision === 32) {\n      const floatBytes = encodeFloat32Bytes(value)\n      bytes = new Uint8Array([0xfa, ...floatBytes])\n    } else if (precision === 64) {\n      const floatBytes = encodeFloat64Bytes(value)\n      bytes = new Uint8Array([0xfb, ...floatBytes])\n    } else {\n      // Auto-detect smallest precision\n      if (canBeFloat16(value)) {\n        const floatBytes = encodeFloat16Bytes(value)\n        bytes = new Uint8Array([0xf9, ...floatBytes])\n      } else if (canBeFloat32(value)) {\n        const floatBytes = encodeFloat32Bytes(value)\n        bytes = new Uint8Array([0xfa, ...floatBytes])\n      } else {\n        // Use float64 for best precision\n        const floatBytes = encodeFloat64Bytes(value)\n        bytes = new Uint8Array([0xfb, ...floatBytes])\n      }\n    }\n\n    return {\n      bytes,\n      hex: bytesToHex(bytes)\n    }\n  }\n\n  return {\n    encodeSimple,\n    encodeFloat\n  }\n}\n","/**\n * CBOR Collection Encoder Composable\n * Handles Major Type 4 (Arrays) and Major Type 5 (Maps)\n * Following RFC 8949 specification\n */\n\nimport type { EncodeResult, EncodeOptions, EncodeContext, EncodableValue } from '../types'\nimport { DEFAULT_ENCODE_OPTIONS, INDEFINITE_SYMBOL, ALL_ENTRIES_SYMBOL } from '../types'\nimport { bytesToHex, concatenateUint8Arrays, compareMapKeys } from '../utils'\nimport { useCborIntegerEncoder } from './useCborIntegerEncoder'\nimport { useCborStringEncoder } from './useCborStringEncoder'\nimport { useCborSimpleEncoder } from './useCborSimpleEncoder'\nimport { useCborByteString, useCborTextString } from '../../parser/composables/useCborStringTypes'\n\ninterface CollectionEncodeOptions {\n  indefinite?: boolean\n}\n\n/**\n * CBOR Collection Encoder Composable\n *\n * Provides functions to encode arrays and maps:\n * - Major Type 4: Arrays\n * - Major Type 5: Maps (objects or Map instances)\n *\n * Supports both definite-length and indefinite-length encoding.\n * Handles canonical encoding with sorted map keys.\n * Enforces depth and size limits.\n *\n * @param options - Global encoder options\n *\n * @example\n * ```ts\n * const { encodeArray, encodeMap } = useCborCollectionEncoder()\n *\n * // Encode array\n * const arr = [1, 2, 3]\n * const result1 = encodeArray(arr)\n * // result1: { bytes: Uint8Array([0x83, 0x01, 0x02, 0x03]), hex: '83010203' }\n *\n * // Encode map\n * const map = { amount: 1000000 }\n * const result2 = encodeMap(map)\n * // result2: { bytes: ..., hex: 'a166616d6f756e741a000f4240' }\n * ```\n */\nexport function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>) {\n  const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions }\n\n  // Get other encoders\n  const { encodeInteger } = useCborIntegerEncoder()\n  const { encodeTextString, encodeByteString } = useCborStringEncoder(globalOptions)\n  const { encodeFloat } = useCborSimpleEncoder(options)\n  const { isCborByteString } = useCborByteString()\n  const { isCborTextString } = useCborTextString()\n\n  /**\n   * Encode a single value (recursive)\n   *\n   * NOTE: This is set by the main encoder to enable recursive encoding of all types\n   * including tagged values. This avoids circular dependencies.\n   */\n  let mainEncode: ((value: EncodableValue) => EncodeResult) | null = null\n\n  /**\n   * Set the main encode function for recursive encoding\n   * This must be called by useCborEncoder before encoding collections\n   */\n  const setMainEncode = (encodeFn: (value: EncodableValue) => EncodeResult) => {\n    mainEncode = encodeFn\n  }\n\n  /**\n   * Encode a single value (recursive)\n   *\n   * @param value - Value to encode\n   * @param ctx - Encoding context for depth tracking\n   * @returns Encoded CBOR bytes\n   */\n  const encodeValue = (value: EncodableValue, ctx: EncodeContext): Uint8Array => {\n    // Check depth limit\n    if (ctx.depth > ctx.options.maxDepth) {\n      throw new Error('Maximum nesting depth exceeded')\n    }\n\n    // Encode based on type\n    if (value === null || value === undefined) {\n      // null/undefined -> CBOR null (0xf6)\n      return new Uint8Array([0xf6])\n    }\n    else if (typeof value === 'boolean') {\n      // true: 0xf5, false: 0xf4\n      return new Uint8Array([value ? 0xf5 : 0xf4])\n    }\n    else if (typeof value === 'number') {\n      if (Object.is(value, -0)) {\n        return encodeFloat(value, 16).bytes\n      }\n      if (Number.isInteger(value) && Number.isSafeInteger(value)) {\n        return encodeInteger(value).bytes\n      }\n      return encodeFloat(value).bytes\n    }\n    else if (typeof value === 'bigint') {\n      return encodeInteger(value).bytes\n    }\n    else if (typeof value === 'string' || isCborTextString(value)) {\n      return encodeTextString(value).bytes\n    }\n    else if (value instanceof Uint8Array || isCborByteString(value)) {\n      return encodeByteString(value).bytes\n    }\n    else if (Array.isArray(value)) {\n      // Recursive array encoding - check for indefinite marker\n      const isIndefinite = (value as any)[INDEFINITE_SYMBOL] === true\n      const newCtx = { ...ctx, depth: ctx.depth + 1 }\n\n      if (isIndefinite) {\n        if (ctx.options.allowIndefinite === false) {\n          throw new Error('Indefinite-length encoding is not allowed')\n        }\n        // Use indefinite encoding - but need to recursively encode items\n        const parts: Uint8Array[] = [new Uint8Array([0x9f])]  // Start marker\n        for (const item of value) {\n          const encoded = encodeValue(item, newCtx)\n          parts.push(encoded)\n        }\n        parts.push(new Uint8Array([0xff]))  // Break marker\n        return concatenateUint8Arrays(parts)\n      } else {\n        return encodeArrayInternal(value, newCtx).bytes\n      }\n    }\n    else if (typeof value === 'object' && value !== null && 'tag' in value && 'value' in value) {\n      // Tagged value - delegate to main encoder if available\n      if (mainEncode) {\n        return mainEncode(value).bytes\n      }\n      throw new Error('Tagged value encoding requires main encoder to be set')\n    }\n    else if (value instanceof Map || (typeof value === 'object' && value !== null)) {\n      // Recursive map encoding - check for indefinite marker\n      const isIndefinite = (value as any)[INDEFINITE_SYMBOL] === true\n      const newCtx = { ...ctx, depth: ctx.depth + 1 }\n\n      if (isIndefinite) {\n        if (ctx.options.allowIndefinite === false) {\n          throw new Error('Indefinite-length encoding is not allowed')\n        }\n        // Use indefinite encoding\n        const entries: Array<[EncodableValue, EncodableValue]> =\n          value instanceof Map\n            ? Array.from(value.entries())\n            : Object.entries(value)\n\n        const parts: Uint8Array[] = [new Uint8Array([0xbf])]  // Start marker\n        for (const [key, val] of entries) {\n          const encodedKey = encodeValue(key, newCtx)\n          const encodedValue = encodeValue(val, newCtx)\n          parts.push(encodedKey)\n          parts.push(encodedValue)\n        }\n        parts.push(new Uint8Array([0xff]))  // Break marker\n        return concatenateUint8Arrays(parts)\n      } else {\n        return encodeMapInternal(value as Map<EncodableValue, EncodableValue> | { [key: string]: EncodableValue }, newCtx).bytes\n      }\n    }\n    else {\n      throw new Error(`Unsupported value type: ${typeof value}`)\n    }\n  }\n\n  /**\n   * Encode length header for arrays and maps\n   *\n   * @param majorType - Major type (4 for arrays, 5 for maps)\n   * @param length - Number of elements\n   * @returns Encoded length header\n   */\n  const encodeLengthHeader = (majorType: number, length: number): Uint8Array => {\n    const baseValue = majorType << 5\n\n    if (length <= 23) {\n      return new Uint8Array([baseValue | length])\n    }\n    else if (length <= 255) {\n      return new Uint8Array([baseValue | 24, length])\n    }\n    else if (length <= 65535) {\n      return new Uint8Array([baseValue | 25, length >> 8, length & 0xff])\n    }\n    else if (length <= 4294967295) {\n      return new Uint8Array([\n        baseValue | 26,\n        (length >> 24) & 0xff,\n        (length >> 16) & 0xff,\n        (length >> 8) & 0xff,\n        length & 0xff\n      ])\n    }\n    else {\n      throw new Error('Collection too large to encode')\n    }\n  }\n\n  /**\n   * Internal array encoding (used by recursive calls)\n   */\n  const encodeArrayInternal = (\n    array: EncodableValue[],\n    ctx: EncodeContext\n  ): EncodeResult => {\n    const header = encodeLengthHeader(4, array.length)\n    const parts: Uint8Array[] = [header]\n\n    // Encode each element\n    for (const item of array) {\n      const encoded = encodeValue(item, ctx)\n      parts.push(encoded)\n    }\n\n    const result = concatenateUint8Arrays(parts)\n\n    return {\n      bytes: result,\n      hex: bytesToHex(result)\n    }\n  }\n\n  /**\n   * Encode array (Major Type 4)\n   *\n   * @param array - Array of encodable values\n   * @param encodeOptions - Encoding options\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeArray = (\n    array: EncodableValue[],\n    encodeOptions?: CollectionEncodeOptions\n  ): EncodeResult => {\n    // Check if array was originally encoded with indefinite length\n    const isIndefinite = (array as any)[INDEFINITE_SYMBOL] === true\n\n    // Handle indefinite-length encoding\n    if (encodeOptions?.indefinite || isIndefinite) {\n      if (options.allowIndefinite === false) {\n        throw new Error('Indefinite-length encoding is not allowed')\n      }\n      if (options.canonical) {\n        throw new Error('Indefinite-length encoding not allowed in canonical mode')\n      }\n      return encodeArrayIndefinite(array)\n    }\n\n    // Definite-length encoding\n    const ctx: EncodeContext = {\n      depth: 0,\n      options\n    }\n\n    return encodeArrayInternal(array, ctx)\n  }\n\n  /**\n   * Encode array with indefinite length\n   *\n   * @param array - Array of encodable values\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeArrayIndefinite = (array: EncodableValue[]): EncodeResult => {\n    if (options.allowIndefinite === false) {\n      throw new Error('Indefinite-length encoding is not allowed')\n    }\n    if (options.canonical) {\n      throw new Error('Indefinite-length encoding not allowed in canonical mode')\n    }\n\n    const parts: Uint8Array[] = [new Uint8Array([0x9f])]  // Start marker\n\n    const ctx: EncodeContext = {\n      depth: 0,\n      options\n    }\n\n    // Encode each element\n    for (const item of array) {\n      const encoded = encodeValue(item, ctx)\n      parts.push(encoded)\n    }\n\n    parts.push(new Uint8Array([0xff]))  // Break marker\n\n    const result = concatenateUint8Arrays(parts)\n\n    return {\n      bytes: result,\n      hex: bytesToHex(result)\n    }\n  }\n\n  /**\n   * Internal map encoding (used by recursive calls)\n   */\n  const encodeMapInternal = (\n    map: Map<EncodableValue, EncodableValue> | { [key: string]: EncodableValue },\n    ctx: EncodeContext\n  ): EncodeResult => {\n    // Check for ALL_ENTRIES_SYMBOL for byte-perfect preservation with duplicates\n    let entries: Array<[EncodableValue, EncodableValue]>\n\n    if ((map as any)[ALL_ENTRIES_SYMBOL]) {\n      // Use the preserved entries (includes duplicates and original order)\n      entries = (map as any)[ALL_ENTRIES_SYMBOL]\n    } else {\n      // Convert object to Map if needed\n      entries = map instanceof Map\n        ? Array.from(map.entries())\n        : Object.entries(map)\n    }\n\n    // Pre-encode keys once for canonical sorting and/or duplicate detection\n    // This avoids re-encoding keys O(N log N) times inside the sort comparator\n    let preEncodedKeys: Uint8Array[] | null = null\n\n    if (ctx.options.canonical && !(map as any)[ALL_ENTRIES_SYMBOL]) {\n      const childCtx = { ...ctx, depth: ctx.depth + 1 }\n      const withEncodedKeys = entries.map(entry => ({\n        encodedKey: encodeValue(entry[0], childCtx),\n        entry\n      }))\n      const keyOrder = ctx.options.mapKeyOrder ?? 'length-first'\n      withEncodedKeys.sort((a, b) => compareMapKeys(a.encodedKey, b.encodedKey, keyOrder))\n      entries = withEncodedKeys.map(t => t.entry)\n      preEncodedKeys = withEncodedKeys.map(t => t.encodedKey)\n    }\n\n    if (ctx.options.rejectDuplicateKeys) {\n      const seen = new Set<string>()\n      // Reuse pre-encoded keys if available (from canonical sort above)\n      const keysForDupCheck = preEncodedKeys\n        ?? entries.map(e => encodeValue(e[0], { ...ctx, depth: ctx.depth + 1 }))\n      for (const keyBytes of keysForDupCheck) {\n        const keyHex = bytesToHex(keyBytes)\n        if (seen.has(keyHex)) {\n          throw new Error('Duplicate map key detected')\n        }\n        seen.add(keyHex)\n      }\n    }\n\n    const header = encodeLengthHeader(5, entries.length)\n    const parts: Uint8Array[] = [header]\n\n    // Encode each key-value pair\n    for (const [key, value] of entries) {\n      const encodedKey = encodeValue(key, ctx)\n      const encodedValue = encodeValue(value, ctx)\n      parts.push(encodedKey)\n      parts.push(encodedValue)\n    }\n\n    const result = concatenateUint8Arrays(parts)\n\n    return {\n      bytes: result,\n      hex: bytesToHex(result)\n    }\n  }\n\n  /**\n   * Encode map (Major Type 5)\n   *\n   * @param map - Map or plain object\n   * @param encodeOptions - Encoding options\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeMap = (\n    map: Map<EncodableValue, EncodableValue> | { [key: string]: EncodableValue },\n    encodeOptions?: CollectionEncodeOptions\n  ): EncodeResult => {\n    // Check if map was originally encoded with indefinite length\n    const isIndefinite = (map as any)[INDEFINITE_SYMBOL] === true\n\n    // Handle indefinite-length encoding\n    if (encodeOptions?.indefinite || isIndefinite) {\n      if (options.allowIndefinite === false) {\n        throw new Error('Indefinite-length encoding is not allowed')\n      }\n      if (options.canonical) {\n        throw new Error('Indefinite-length encoding not allowed in canonical mode')\n      }\n      return encodeMapIndefinite(map)\n    }\n\n    // Definite-length encoding\n    const ctx: EncodeContext = {\n      depth: 0,\n      options\n    }\n\n    return encodeMapInternal(map, ctx)\n  }\n\n  /**\n   * Encode map with indefinite length\n   *\n   * @param map - Map or plain object\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeMapIndefinite = (\n    map: Map<EncodableValue, EncodableValue> | { [key: string]: EncodableValue }\n  ): EncodeResult => {\n    if (options.allowIndefinite === false) {\n      throw new Error('Indefinite-length encoding is not allowed')\n    }\n    if (options.canonical) {\n      throw new Error('Indefinite-length encoding not allowed in canonical mode')\n    }\n\n    const entries: Array<[EncodableValue, EncodableValue]> =\n      map instanceof Map\n        ? Array.from(map.entries())\n        : Object.entries(map)\n\n    const parts: Uint8Array[] = [new Uint8Array([0xbf])]  // Start marker\n\n    const ctx: EncodeContext = {\n      depth: 0,\n      options\n    }\n\n    // Encode each key-value pair\n    for (const [key, value] of entries) {\n      const encodedKey = encodeValue(key, ctx)\n      const encodedValue = encodeValue(value, ctx)\n      parts.push(encodedKey)\n      parts.push(encodedValue)\n    }\n\n    parts.push(new Uint8Array([0xff]))  // Break marker\n\n    const result = concatenateUint8Arrays(parts)\n\n    return {\n      bytes: result,\n      hex: bytesToHex(result)\n    }\n  }\n\n  return {\n    encodeArray,\n    encodeArrayIndefinite,\n    encodeMap,\n    encodeMapIndefinite,\n    setMainEncode\n  }\n}\n","/**\n * CBOR Tag Encoder Composable\n * Handles Major Type 6 (Semantic Tags)\n * Following RFC 8949 specification\n */\n\nimport type { EncodeResult, TaggedValue, EncodableValue } from '../types'\nimport { bytesToHex, writeUint, writeBigUint } from '../utils'\n\n/**\n * CBOR Tag Encoder Composable\n *\n * Provides functions to encode tagged values to CBOR format:\n * - Major Type 6: Semantic tags (0 to 2^64-1)\n *\n * Tags provide semantic meaning to CBOR values:\n * - Tag 0: Date/time string (RFC 3339)\n * - Tag 1: Epoch timestamp\n * - Tag 2: Positive bignum\n * - Tag 3: Negative bignum\n * - Tag 258: Cardano set (CIP-0005)\n * - And many more...\n *\n * @example\n * ```ts\n * const { encodeTag } = useCborTagEncoder()\n *\n * // Encode date/time string (tag 0)\n * const result1 = encodeTag(0, '2013-03-21T20:04:00Z', encode)\n * // result1.hex: 'c074323031332d30332d32315432303a30343a30305a'\n *\n * // Encode positive bignum (tag 2)\n * const result2 = encodeTag(2, new Uint8Array([0x01, 0xff]), encode)\n * // result2.hex: 'c24201ff'\n *\n * // Encode Cardano set (tag 258)\n * const result3 = encodeTag(258, [1, 2, 3], encode)\n * // result3.hex: 'd9010283010203'\n * ```\n */\nexport function useCborTagEncoder() {\n  /**\n   * Encode tag number (Major Type 6 header)\n   *\n   * Tag numbers use the same encoding rules as unsigned integers:\n   * - 0-23: Direct encoding in initial byte (0xc0-0xd7)\n   * - 24-255: 0xd8 + 1 byte\n   * - 256-65535: 0xd9 + 2 bytes\n   * - 65536-4294967295: 0xda + 4 bytes\n   * - 4294967296-2^64-1: 0xdb + 8 bytes\n   *\n   * @param tagNumber - Tag number (0 to 2^64-1)\n   * @returns Encoded tag header bytes\n   * @throws Error if tag number is negative or >= 2^64\n   */\n  const encodeTagNumber = (tagNumber: number | bigint): Uint8Array => {\n    // Convert to BigInt for consistent handling\n    const bigTag = typeof tagNumber === 'bigint' ? tagNumber : BigInt(tagNumber)\n\n    // Validate tag is non-negative\n    if (bigTag < 0n) {\n      throw new Error('Tag number cannot be negative')\n    }\n\n    // Validate tag doesn't exceed 2^64-1\n    const MAX_UINT64 = 18446744073709551615n  // 2^64 - 1\n    if (bigTag > MAX_UINT64) {\n      throw new Error('Tag number exceeds maximum (2^64-1)')\n    }\n\n    let bytes: Uint8Array\n\n    // Direct encoding (0-23) - Major type 6 (0xc0) + tag number\n    if (bigTag <= 23n) {\n      bytes = new Uint8Array([0xc0 + Number(bigTag)])\n    }\n    // 1-byte encoding (24-255) - 0xd8 + 1 byte\n    else if (bigTag <= 255n) {\n      bytes = new Uint8Array([0xd8, Number(bigTag)])\n    }\n    // 2-byte encoding (256-65535) - 0xd9 + 2 bytes\n    else if (bigTag <= 65535n) {\n      const valueBytes = writeUint(Number(bigTag), 2)\n      bytes = new Uint8Array([0xd9, ...valueBytes])\n    }\n    // 4-byte encoding (65536-4294967295) - 0xda + 4 bytes\n    else if (bigTag <= 4294967295n) {\n      const valueBytes = writeUint(Number(bigTag), 4)\n      bytes = new Uint8Array([0xda, ...valueBytes])\n    }\n    // 8-byte encoding (> 4294967295) - 0xdb + 8 bytes\n    else {\n      const valueBytes = writeBigUint(bigTag, 8)\n      bytes = new Uint8Array([0xdb, ...valueBytes])\n    }\n\n    return bytes\n  }\n\n  /**\n   * Encode tagged value (tag + content)\n   *\n   * A tagged value consists of:\n   * 1. Tag number (Major Type 6 header)\n   * 2. Tagged content (recursively encoded value)\n   *\n   * The encode function is passed as a parameter to avoid circular dependencies.\n   *\n   * @param tagNumber - Tag number\n   * @param value - Value to tag\n   * @param encode - Encoder function for the tagged value\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeTag = (\n    tagNumber: number | bigint,\n    value: EncodableValue,\n    encode: (value: EncodableValue) => EncodeResult\n  ): EncodeResult => {\n    // Encode tag number\n    const tagBytes = encodeTagNumber(tagNumber)\n\n    // Recursively encode the tagged value\n    const valueResult = encode(value)\n\n    // Concatenate tag header + value bytes\n    const totalLength = tagBytes.length + valueResult.bytes.length\n    const bytes = new Uint8Array(totalLength)\n    bytes.set(tagBytes, 0)\n    bytes.set(valueResult.bytes, tagBytes.length)\n\n    return {\n      bytes,\n      hex: bytesToHex(bytes)\n    }\n  }\n\n  /**\n   * Encode TaggedValue object\n   *\n   * Convenience function for encoding { tag, value } objects.\n   *\n   * @param taggedValue - Object with tag and value properties\n   * @param encode - Encoder function for the tagged value\n   * @returns Encoded CBOR bytes and hex string\n   */\n  const encodeTaggedValue = (\n    taggedValue: TaggedValue,\n    encode: (value: EncodableValue) => EncodeResult\n  ): EncodeResult => {\n    return encodeTag(taggedValue.tag, taggedValue.value, encode)\n  }\n\n  return {\n    encodeTagNumber,\n    encodeTag,\n    encodeTaggedValue\n  }\n}\n","/**\n * Main CBOR Encoder Composable\n * High-level API for encoding JavaScript values to CBOR\n * Following RFC 8949 specification\n */\n\nimport type { EncodeResult, EncodeOptions, EncodableValue, TaggedValue } from '../types'\nimport { DEFAULT_ENCODE_OPTIONS } from '../types'\nimport { useCborIntegerEncoder } from './useCborIntegerEncoder'\nimport { useCborStringEncoder } from './useCborStringEncoder'\nimport { useCborCollectionEncoder } from './useCborCollectionEncoder'\nimport { useCborSimpleEncoder } from './useCborSimpleEncoder'\nimport { useCborTagEncoder } from './useCborTagEncoder'\nimport { useCborByteString, useCborTextString } from '../../parser/composables/useCborStringTypes'\n\n/**\n * Main CBOR Encoder Composable\n *\n * Provides a unified interface for encoding any JavaScript value to CBOR.\n * Automatically selects the appropriate encoder based on value type.\n *\n * @param options - Global encoder options\n *\n * @example\n * ```ts\n * const { encode } = useCborEncoder()\n *\n * // Encode various types\n * encode(42)           // Integer\n * encode(\"hello\")      // Text string\n * encode([1, 2, 3])    // Array\n * encode({ a: 1 })     // Map\n * encode(true)         // Boolean\n * encode(3.14)         // Float\n * encode(new Uint8Array([0xff]))  // Byte string\n *\n * // With options\n * const { encode: encodeCanonical } = useCborEncoder({ canonical: true })\n * encodeCanonical({ z: 1, a: 2 })  // Keys will be sorted\n * ```\n */\nexport function useCborEncoder(globalOptions?: Partial<EncodeOptions>) {\n  const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions }\n\n  // Canonical mode overrides: indefinite-length is forbidden per RFC 8949 Section 4.2\n  if (options.canonical && options.allowIndefinite) {\n    options.allowIndefinite = false\n  }\n\n  // Get all specialized encoders\n  const { encodeInteger } = useCborIntegerEncoder()\n  const { encodeTextString, encodeByteString } = useCborStringEncoder(options)\n  const { encodeArray, encodeMap, setMainEncode } = useCborCollectionEncoder(options)\n  const { encodeSimple, encodeFloat } = useCborSimpleEncoder(options)\n  const { encodeTaggedValue } = useCborTagEncoder()\n\n  // Get type guards for composable string types\n  const { isCborByteString } = useCborByteString()\n  const { isCborTextString } = useCborTextString()\n\n  /**\n   * Encode any JavaScript value to CBOR\n   *\n   * Automatically detects the type and uses the appropriate encoder:\n   * - number/bigint → Integer or Float\n   * - string → Text string\n   * - boolean/null/undefined → Simple values\n   * - Uint8Array → Byte string\n   * - Array → CBOR array\n   * - {tag: number, value: any} → Tagged value\n   * - Object/Map → CBOR map\n   *\n   * @param value - Value to encode\n   * @returns Encoded CBOR bytes and hex string\n   * @throws Error if value type is unsupported\n   */\n  const encode = (value: EncodableValue): EncodeResult => {\n    const result = encodeValue(value)\n\n    // Enforce maxOutputSize at the root level.\n    // This is the single authoritative check — collection/string encoders no longer\n    // track bytesWritten individually, which was broken for nested structures.\n    if (options.maxOutputSize && result.bytes.length > options.maxOutputSize) {\n      throw new Error(\n        `Encoded output size ${result.bytes.length} bytes exceeds limit of ${options.maxOutputSize} bytes`\n      )\n    }\n\n    return result\n  }\n\n  // Recursion depth tracked across ALL value types — including the tag boundary.\n  // Tagged values re-enter through this same encode()/encodeValue() pair, so\n  // counting here (rather than only inside the collection encoder) prevents a\n  // deeply nested {tag,value} chain from silently bypassing maxDepth and\n  // overflowing the call stack.\n  let currentDepth = 0\n\n  /**\n   * Encode any JavaScript value to CBOR (internal, no size check)\n   */\n  const encodeValue = (value: EncodableValue): EncodeResult => {\n    if (currentDepth > options.maxDepth) {\n      throw new Error(`Maximum nesting depth ${options.maxDepth} exceeded`)\n    }\n    currentDepth++\n    try {\n      return encodeValueInner(value)\n    } finally {\n      currentDepth--\n    }\n  }\n\n  const encodeValueInner = (value: EncodableValue): EncodeResult => {\n    // Handle null/undefined/boolean\n    if (value === null || value === undefined || typeof value === 'boolean') {\n      return encodeSimple(value)\n    }\n\n    // Handle numbers\n    if (typeof value === 'number') {\n      if (Object.is(value, -0)) {\n        return encodeFloat(value, 16)\n      }\n      // Check if it's an integer\n      if (Number.isSafeInteger(value)) {\n        return encodeInteger(value)\n      }\n      // It's a float\n      return encodeFloat(value)\n    }\n\n    // Handle bigint\n    if (typeof value === 'bigint') {\n      return encodeInteger(value)\n    }\n\n    // Handle composable text strings (check before primitive strings)\n    if (isCborTextString(value)) {\n      return encodeTextString(value)\n    }\n\n    // Handle strings\n    if (typeof value === 'string') {\n      return encodeTextString(value)\n    }\n\n    // Handle composable byte strings (check before Uint8Array)\n    if (isCborByteString(value)) {\n      return encodeByteString(value)\n    }\n\n    // Handle Uint8Array (byte strings)\n    if (value instanceof Uint8Array) {\n      return encodeByteString(value)\n    }\n\n    // Handle arrays\n    if (Array.isArray(value)) {\n      return encodeArray(value)\n    }\n\n    // Handle Map\n    if (value instanceof Map) {\n      return encodeMap(value)\n    }\n\n    // Handle tagged values (MUST come before plain objects)\n    // Check for {tag: number, value: any} structure\n    if (typeof value === 'object' && value !== null && 'tag' in value && 'value' in value && typeof (value as { tag: unknown }).tag === 'number') {\n      return encodeTaggedValue(value as TaggedValue, encode)\n    }\n\n    // Handle plain objects\n    if (typeof value === 'object' && value !== null) {\n      return encodeMap(value as { [key: string]: EncodableValue })\n    }\n\n    throw new Error(`Unsupported value type: ${typeof value}`)\n  }\n\n  // Set the main encode function for recursive collection encoding\n  // This allows the collection encoder to handle nested tagged values\n  setMainEncode(encode)\n\n  /**\n   * Encode value and return only the hex string\n   *\n   * @param value - Value to encode\n   * @returns Hex string representation\n   */\n  const encodeToHex = (value: EncodableValue): string => {\n    return encode(value).hex\n  }\n\n  /**\n   * Encode value and return only the bytes\n   *\n   * @param value - Value to encode\n   * @returns Uint8Array bytes\n   */\n  const encodeToBytes = (value: EncodableValue): Uint8Array => {\n    return encode(value).bytes\n  }\n\n  /**\n   * Encode multiple values in sequence\n   *\n   * Useful for CBOR sequences (RFC 8742)\n   *\n   * @param values - Values to encode\n   * @returns Concatenated CBOR encoding\n   */\n  const encodeSequence = (values: EncodableValue[]): EncodeResult => {\n    const allBytes: Uint8Array[] = []\n\n    for (const value of values) {\n      const result = encode(value)\n      allBytes.push(result.bytes)\n    }\n\n    // Concatenate all encoded values\n    const totalLength = allBytes.reduce((sum, arr) => sum + arr.length, 0)\n    const concatenated = new Uint8Array(totalLength)\n\n    let offset = 0\n    for (const bytes of allBytes) {\n      concatenated.set(bytes, offset)\n      offset += bytes.length\n    }\n\n    const hex = Array.from(concatenated)\n      .map(b => b.toString(16).padStart(2, '0'))\n      .join('')\n\n    return {\n      bytes: concatenated,\n      hex\n    }\n  }\n\n  return {\n    encode,\n    encodeToHex,\n    encodeToBytes,\n    encodeSequence\n  }\n}\n"]}

package/dist/{chunk-S4RXO6IB.cjs → chunk-HMUA5KLG.cjs}

@@ -1,12 +1,13 @@
 'use strict';
 
-var chunkPD72MVTX_cjs = require('./chunk-PD72MVTX.cjs');
+var chunkP6A2OOIY_cjs = require('./chunk-P6A2OOIY.cjs');
 
 // src/encoder/types.ts
 var DEFAULT_ENCODE_OPTIONS = {
   canonical: false,
   allowIndefinite: true,
   rejectDuplicateKeys: false,
+  mapKeyOrder: "length-first",
   maxDepth: 64,
   maxOutputSize: 100 * 1024 * 1024
   // 100 MB
@@ -42,6 +43,20 @@ function compareBytes(a, b) {
   }
   return 0;
 }
+function compareBytesLexicographic(a, b) {
+  const min = Math.min(a.length, b.length);
+  for (let i = 0; i < min; i++) {
+    const byteA = a[i];
+    const byteB = b[i];
+    if (byteA !== byteB) {
+      return byteA - byteB;
+    }
+  }
+  return a.length - b.length;
+}
+function compareMapKeys(a, b, order = "length-first") {
+  return order === "bytewise" ? compareBytesLexicographic(a, b) : compareBytes(a, b);
+}
 function writeUint(value, bytes) {
   const result = new Uint8Array(bytes);
   for (let i = bytes - 1; i >= 0; i--) {
@@ -138,8 +153,8 @@ function useCborIntegerEncoder() {
 // src/encoder/composables/useCborStringEncoder.ts
 function useCborStringEncoder(globalOptions) {
   const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions };
-  const { isCborByteString } = chunkPD72MVTX_cjs.useCborByteString();
-  const { isCborTextString } = chunkPD72MVTX_cjs.useCborTextString();
+  const { isCborByteString } = chunkP6A2OOIY_cjs.useCborByteString();
+  const { isCborTextString } = chunkP6A2OOIY_cjs.useCborTextString();
   const encodeLengthHeader = (majorType, length) => {
     const baseValue = majorType << 5;
     if (length <= 23) {
@@ -158,7 +173,7 @@ function useCborStringEncoder(globalOptions) {
     }
   };
   const encodeByteString = (data, encodeOptions) => {
-    const isIndefinite = isCborByteString(data) && data[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+    const isIndefinite = isCborByteString(data) && data[chunkP6A2OOIY_cjs.INDEFINITE_SYMBOL] === true;
     if (encodeOptions?.indefinite || Array.isArray(data) || isIndefinite) {
       if (options.allowIndefinite === false) {
         throw new Error("Indefinite-length encoding is not allowed");
@@ -204,7 +219,7 @@ function useCborStringEncoder(globalOptions) {
     };
   };
   const encodeTextString = (text, encodeOptions) => {
-    const isIndefinite = isCborTextString(text) && text[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+    const isIndefinite = isCborTextString(text) && text[chunkP6A2OOIY_cjs.INDEFINITE_SYMBOL] === true;
     if (encodeOptions?.indefinite || isIndefinite) {
       if (options.allowIndefinite === false) {
         throw new Error("Indefinite-length encoding is not allowed");
@@ -352,7 +367,7 @@ function useCborSimpleEncoder(_globalOptions) {
       return true;
     }
     const absValue = Math.abs(value);
-    if (absValue < 6103515625e-14 || absValue > 65504) {
+    if (absValue < 5960464477539063e-23 || absValue > 65504) {
       return false;
     }
     const bytes = encodeFloat16Bytes(value);
@@ -427,8 +442,8 @@ function useCborCollectionEncoder(globalOptions) {
   const { encodeInteger } = useCborIntegerEncoder();
   const { encodeTextString, encodeByteString } = useCborStringEncoder(globalOptions);
   const { encodeFloat } = useCborSimpleEncoder();
-  const { isCborByteString } = chunkPD72MVTX_cjs.useCborByteString();
-  const { isCborTextString } = chunkPD72MVTX_cjs.useCborTextString();
+  const { isCborByteString } = chunkP6A2OOIY_cjs.useCborByteString();
+  const { isCborTextString } = chunkP6A2OOIY_cjs.useCborTextString();
   let mainEncode = null;
   const setMainEncode = (encodeFn) => {
     mainEncode = encodeFn;
@@ -456,7 +471,7 @@ function useCborCollectionEncoder(globalOptions) {
     } else if (value instanceof Uint8Array || isCborByteString(value)) {
       return encodeByteString(value).bytes;
     } else if (Array.isArray(value)) {
-      const isIndefinite = value[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+      const isIndefinite = value[chunkP6A2OOIY_cjs.INDEFINITE_SYMBOL] === true;
       const newCtx = { ...ctx, depth: ctx.depth + 1 };
       if (isIndefinite) {
         if (ctx.options.allowIndefinite === false) {
@@ -478,7 +493,7 @@ function useCborCollectionEncoder(globalOptions) {
       }
       throw new Error("Tagged value encoding requires main encoder to be set");
     } else if (value instanceof Map || typeof value === "object" && value !== null) {
-      const isIndefinite = value[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+      const isIndefinite = value[chunkP6A2OOIY_cjs.INDEFINITE_SYMBOL] === true;
       const newCtx = { ...ctx, depth: ctx.depth + 1 };
       if (isIndefinite) {
         if (ctx.options.allowIndefinite === false) {
@@ -535,7 +550,7 @@ function useCborCollectionEncoder(globalOptions) {
     };
   };
   const encodeArray = (array, encodeOptions) => {
-    const isIndefinite = array[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+    const isIndefinite = array[chunkP6A2OOIY_cjs.INDEFINITE_SYMBOL] === true;
     if (encodeOptions?.indefinite || isIndefinite) {
       if (options.allowIndefinite === false) {
         throw new Error("Indefinite-length encoding is not allowed");
@@ -576,19 +591,20 @@ function useCborCollectionEncoder(globalOptions) {
   };
   const encodeMapInternal = (map, ctx) => {
     let entries;
-    if (map[chunkPD72MVTX_cjs.ALL_ENTRIES_SYMBOL]) {
-      entries = map[chunkPD72MVTX_cjs.ALL_ENTRIES_SYMBOL];
+    if (map[chunkP6A2OOIY_cjs.ALL_ENTRIES_SYMBOL]) {
+      entries = map[chunkP6A2OOIY_cjs.ALL_ENTRIES_SYMBOL];
     } else {
       entries = map instanceof Map ? Array.from(map.entries()) : Object.entries(map);
     }
     let preEncodedKeys = null;
-    if (ctx.options.canonical && !map[chunkPD72MVTX_cjs.ALL_ENTRIES_SYMBOL]) {
+    if (ctx.options.canonical && !map[chunkP6A2OOIY_cjs.ALL_ENTRIES_SYMBOL]) {
       const childCtx = { ...ctx, depth: ctx.depth + 1 };
       const withEncodedKeys = entries.map((entry) => ({
         encodedKey: encodeValue(entry[0], childCtx),
         entry
       }));
-      withEncodedKeys.sort((a, b) => compareBytes(a.encodedKey, b.encodedKey));
+      const keyOrder = ctx.options.mapKeyOrder ?? "length-first";
+      withEncodedKeys.sort((a, b) => compareMapKeys(a.encodedKey, b.encodedKey, keyOrder));
       entries = withEncodedKeys.map((t) => t.entry);
       preEncodedKeys = withEncodedKeys.map((t) => t.encodedKey);
     }
@@ -618,7 +634,7 @@ function useCborCollectionEncoder(globalOptions) {
     };
   };
   const encodeMap = (map, encodeOptions) => {
-    const isIndefinite = map[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+    const isIndefinite = map[chunkP6A2OOIY_cjs.INDEFINITE_SYMBOL] === true;
     if (encodeOptions?.indefinite || isIndefinite) {
       if (options.allowIndefinite === false) {
         throw new Error("Indefinite-length encoding is not allowed");
@@ -730,8 +746,8 @@ function useCborEncoder(globalOptions) {
   const { encodeArray, encodeMap, setMainEncode } = useCborCollectionEncoder(options);
   const { encodeSimple, encodeFloat } = useCborSimpleEncoder();
   const { encodeTaggedValue } = useCborTagEncoder();
-  const { isCborByteString } = chunkPD72MVTX_cjs.useCborByteString();
-  const { isCborTextString } = chunkPD72MVTX_cjs.useCborTextString();
+  const { isCborByteString } = chunkP6A2OOIY_cjs.useCborByteString();
+  const { isCborTextString } = chunkP6A2OOIY_cjs.useCborTextString();
   const encode = (value) => {
     const result = encodeValue(value);
     if (options.maxOutputSize && result.bytes.length > options.maxOutputSize) {
@@ -741,7 +757,19 @@ function useCborEncoder(globalOptions) {
     }
     return result;
   };
+  let currentDepth = 0;
   const encodeValue = (value) => {
+    if (currentDepth > options.maxDepth) {
+      throw new Error(`Maximum nesting depth ${options.maxDepth} exceeded`);
+    }
+    currentDepth++;
+    try {
+      return encodeValueInner(value);
+    } finally {
+      currentDepth--;
+    }
+  };
+  const encodeValueInner = (value) => {
     if (value === null || value === void 0 || typeof value === "boolean") {
       return encodeSimple(value);
     }
@@ -829,5 +857,5 @@ exports.useCborStringEncoder = useCborStringEncoder;
 exports.useCborTagEncoder = useCborTagEncoder;
 exports.writeBigUint = writeBigUint;
 exports.writeUint = writeUint;
-//# sourceMappingURL=chunk-S4RXO6IB.cjs.map
-//# sourceMappingURL=chunk-S4RXO6IB.cjs.map
+//# sourceMappingURL=chunk-HMUA5KLG.cjs.map
+//# sourceMappingURL=chunk-HMUA5KLG.cjs.map