@marcuspuchalla/nachos 0.1.1 → 0.1.3

package/src/parser/composables/useCborTag.ts

@@ -4,8 +4,8 @@
  * Supports standard tags (0-5), encoding hints (21-36), self-describe (55799), and Cardano tags
  */
 
-import type { ParseResult, CborValue, TaggedValue, CborMap, ParseOptions, PlutusConstr } from '../types'
-import { INDEFINITE_SYMBOL } from '../types'
+import type { ParseResult, CborValue, TaggedValue, CborMap, ParseOptions, PlutusConstr, CborByteString } from '../types'
+import { INDEFINITE_SYMBOL, DEFAULT_LIMITS } from '../types'
 import { hexToBytes, readByte, readUint, readBigUint, extractCborHeader, hasDuplicates } from '../utils'
 import { useCborInteger } from './useCborInteger'
 import { useCborString } from './useCborString'
@@ -37,7 +37,7 @@ export function useCborTag() {
    * @param tagDepth - Current tag nesting depth (for limit checking)
    * @returns Parsed value and bytes consumed
    */
-  const parseItem = (buffer: Uint8Array, offset: number, options?: ParseOptions, tagDepth: number = 0): ParseResult => {
+  const parseItem = (buffer: Uint8Array, offset: number, options?: ParseOptions, tagDepth: number = 0, collectionDepth: number = 0): ParseResult => {
     if (offset >= buffer.length) {
       throw new Error(`Unexpected end of buffer at offset ${offset}`)
     }
@@ -64,10 +64,10 @@ export function useCborTag() {
         return parseTextString(buffer, offset, options)
 
       case 4: // Array
-        return parseArrayInternal(buffer, offset, options)
+        return parseArrayInternal(buffer, offset, options, collectionDepth)
 
       case 5: // Map
-        return parseMapInternal(buffer, offset, options)
+        return parseMapInternal(buffer, offset, options, collectionDepth)
 
       case 6: // Tag (recursive)
         return parseTagFromBuffer(buffer, offset, options, tagDepth)
@@ -96,9 +96,10 @@ export function useCborTag() {
   }
 
   /**
-   * Internal array parser that uses the tag-aware parseItem
+   * Internal array parser with full security checks
+   * Mirrors useCborCollection.parseArrayFromBuffer security hardening
    */
-  const parseArrayInternal = (buffer: Uint8Array, offset: number, options?: ParseOptions): ParseResult => {
+  const parseArrayInternal = (buffer: Uint8Array, offset: number, options?: ParseOptions, depth: number = 0): ParseResult => {
     const initialByte = readByte(buffer, offset)
     const { majorType, additionalInfo } = extractCborHeader(initialByte)
 
@@ -106,6 +107,18 @@ export function useCborTag() {
       throw new Error(`Expected major type 4 (array), got ${majorType}`)
     }
 
+    // Check if indefinite length is allowed
+    const isIndefiniteAllowed = options?.allowIndefinite ?? !(options?.validateCanonical || options?.strict)
+    if (additionalInfo === 31 && !isIndefiniteAllowed) {
+      throw new Error('Indefinite-length encoding is not allowed (strict/canonical mode)')
+    }
+
+    // Check depth limit before descending
+    const maxDepth = options?.limits?.maxDepth ?? DEFAULT_LIMITS.maxDepth
+    if (depth >= maxDepth) {
+      throw new Error(`Maximum nesting depth ${maxDepth} exceeded`)
+    }
+
     // Parse length
     let length: number | null
     let bytesConsumed: number
@@ -136,20 +149,39 @@ export function useCborTag() {
       throw new Error(`Invalid additional info for array: ${additionalInfo}`)
     }
 
+    // Check array length limit before parsing
+    if (length !== null && options?.limits?.maxArrayLength && length > options.limits.maxArrayLength) {
+      throw new Error(`Array length ${length} exceeds limit of ${options.limits.maxArrayLength}`)
+    }
+
     let currentOffset = offset + 1 + bytesConsumed
     const items: CborValue[] = []
 
     if (length === null) {
       // Indefinite-length array
+      let index = 0
+      let foundBreak = false
       while (currentOffset < buffer.length) {
         const nextByte = readByte(buffer, currentOffset)
         if (nextByte === 0xff) {
           currentOffset++
+          foundBreak = true
           break
         }
-        const itemResult = parseItem(buffer, currentOffset, options)
+
+        // Check array length limit
+        if (options?.limits?.maxArrayLength && index >= options.limits.maxArrayLength) {
+          throw new Error(`Array length exceeds limit of ${options.limits.maxArrayLength}`)
+        }
+
+        const itemResult = parseItem(buffer, currentOffset, options, 0, depth + 1)
         items.push(itemResult.value)
         currentOffset += itemResult.bytesRead
+        index++
+      }
+
+      if (!foundBreak) {
+        throw new Error('Indefinite-length array missing break code (0xFF)')
       }
 
       // Mark as indefinite-length for round-trip preservation
@@ -157,7 +189,10 @@ export function useCborTag() {
     } else {
       // Definite-length array
       for (let i = 0; i < length; i++) {
-        const itemResult = parseItem(buffer, currentOffset, options)
+        if (currentOffset >= buffer.length) {
+          throw new Error(`Unexpected end of buffer while parsing array element ${i}/${length}`)
+        }
+        const itemResult = parseItem(buffer, currentOffset, options, 0, depth + 1)
         items.push(itemResult.value)
         currentOffset += itemResult.bytesRead
       }
@@ -170,9 +205,10 @@ export function useCborTag() {
   }
 
   /**
-   * Internal map parser that uses the tag-aware parseItem
+   * Internal map parser with full security checks
+   * Mirrors useCborCollection.parseMapFromBuffer security hardening
    */
-  const parseMapInternal = (buffer: Uint8Array, offset: number, options?: ParseOptions): ParseResult => {
+  const parseMapInternal = (buffer: Uint8Array, offset: number, options?: ParseOptions, depth: number = 0): ParseResult => {
     const initialByte = readByte(buffer, offset)
     const { majorType, additionalInfo } = extractCborHeader(initialByte)
 
@@ -180,6 +216,18 @@ export function useCborTag() {
       throw new Error(`Expected major type 5 (map), got ${majorType}`)
     }
 
+    // Check if indefinite length is allowed
+    const isIndefiniteAllowed = options?.allowIndefinite ?? !(options?.validateCanonical || options?.strict)
+    if (additionalInfo === 31 && !isIndefiniteAllowed) {
+      throw new Error('Indefinite-length encoding is not allowed (strict/canonical mode)')
+    }
+
+    // Check depth limit before descending
+    const maxDepth = options?.limits?.maxDepth ?? DEFAULT_LIMITS.maxDepth
+    if (depth >= maxDepth) {
+      throw new Error(`Maximum nesting depth ${maxDepth} exceeded`)
+    }
+
     // Parse length
     let length: number | null
     let bytesConsumed: number
@@ -210,25 +258,44 @@ export function useCborTag() {
       throw new Error(`Invalid additional info for map: ${additionalInfo}`)
     }
 
+    // Check map size limit before parsing
+    if (length !== null && options?.limits?.maxMapSize && length > options.limits.maxMapSize) {
+      throw new Error(`Map size ${length} exceeds limit of ${options.limits.maxMapSize}`)
+    }
+
     let currentOffset = offset + 1 + bytesConsumed
     const map: CborMap = new Map()
 
     if (length === null) {
       // Indefinite-length map
+      let index = 0
+      let foundBreak = false
       while (currentOffset < buffer.length) {
         const nextByte = readByte(buffer, currentOffset)
         if (nextByte === 0xff) {
           currentOffset++
+          foundBreak = true
           break
         }
-        const keyResult = parseItem(buffer, currentOffset, options)
+
+        // Check map size limit
+        if (options?.limits?.maxMapSize && index >= options.limits.maxMapSize) {
+          throw new Error(`Map size exceeds limit of ${options.limits.maxMapSize}`)
+        }
+
+        const keyResult = parseItem(buffer, currentOffset, options, 0, depth + 1)
         currentOffset += keyResult.bytesRead
 
-        const valueResult = parseItem(buffer, currentOffset, options)
+        const valueResult = parseItem(buffer, currentOffset, options, 0, depth + 1)
         currentOffset += valueResult.bytesRead
 
         // Store with original key type (not string!)
         map.set(keyResult.value, valueResult.value)
+        index++
+      }
+
+      if (!foundBreak) {
+        throw new Error('Indefinite-length map missing break code (0xFF)')
       }
 
       // Mark as indefinite-length for round-trip preservation
@@ -236,10 +303,14 @@ export function useCborTag() {
     } else {
       // Definite-length map
       for (let i = 0; i < length; i++) {
-        const keyResult = parseItem(buffer, currentOffset, options)
+        if (currentOffset >= buffer.length) {
+          throw new Error(`Unexpected end of buffer while parsing map entry ${i}/${length}`)
+        }
+
+        const keyResult = parseItem(buffer, currentOffset, options, 0, depth + 1)
         currentOffset += keyResult.bytesRead
 
-        const valueResult = parseItem(buffer, currentOffset, options)
+        const valueResult = parseItem(buffer, currentOffset, options, 0, depth + 1)
         currentOffset += valueResult.bytesRead
 
         // Store with original key type (not string!)
@@ -336,6 +407,14 @@ export function useCborTag() {
     return false
   }
 
+  const isByteString = (value: CborValue): value is Uint8Array | CborByteString => {
+    if (value instanceof Uint8Array) return true
+    if (value && typeof value === 'object' && 'type' in value && (value as any).type === 'cbor-byte-string') {
+      return true
+    }
+    return false
+  }
+
   /**
    * Gets string value from CborTextString or plain string
    */
@@ -373,6 +452,15 @@ export function useCborTag() {
         }
         break
 
+      case 2: // Positive bignum
+      case 3: // Negative bignum
+        if (!shouldValidateStandard) break
+
+        if (!isByteString(value)) {
+          throw new Error(`Tag ${tagNumber} (bignum) must contain a byte string, got ${typeof value}`)
+        }
+        break
+
       case 4: // Decimal Fraction
         if (!shouldValidateStandard) break
 
@@ -650,7 +738,7 @@ export function useCborTag() {
     }
 
     // Check tag nesting depth limit (RUSTSEC-2019-0025 mitigation)
-    const maxTagDepth = options?.limits?.maxTagDepth ?? 64
+    const maxTagDepth = options?.limits?.maxTagDepth ?? DEFAULT_LIMITS.maxTagDepth
     if (tagDepth >= maxTagDepth) {
       throw new Error(`Tag nesting depth ${tagDepth} exceeds limit of ${maxTagDepth}`)
     }

package/dist/chunk-2FUTHZQQ.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/encoder/types.ts","../src/encoder/utils.ts","../src/encoder/composables/useCborIntegerEncoder.ts","../src/encoder/composables/useCborStringEncoder.ts","../src/encoder/composables/useCborCollectionEncoder.ts","../src/encoder/composables/useCborSimpleEncoder.ts","../src/encoder/composables/useCborTagEncoder.ts","../src/encoder/composables/useCborEncoder.ts"],"names":["useCborByteString","useCborTextString","INDEFINITE_SYMBOL","bytes","textStr","ALL_ENTRIES_SYMBOL"],"mappings":"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","file":"chunk-2FUTHZQQ.cjs","sourcesContent":["/**\n * CBOR Encoder Type Definitions\n * Following RFC 8949 specification\n */\n\nimport type { PlutusConstr, CborByteString, CborTextString } 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 }\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  /** 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  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  /** Bytes written so far */\n  bytesWritten: 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 bytewise (for canonical map sorting)\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 * 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.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    const header = encodeLengthHeader(2, bytes.length)\n    const result = concatenateUint8Arrays([header, bytes])\n\n    // Check output size limit\n    if (result.length > options.maxOutputSize) {\n      throw new Error('Encoded output exceeds maximum size')\n    }\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.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.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    const header = encodeLengthHeader(3, utf8Bytes.length)\n    const result = concatenateUint8Arrays([header, utf8Bytes])\n\n    // Check output size limit\n    if (result.length > options.maxOutputSize) {\n      throw new Error('Encoded output exceeds maximum size')\n    }\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.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 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, compareBytes } from '../utils'\nimport { useCborIntegerEncoder } from './useCborIntegerEncoder'\nimport { useCborStringEncoder } from './useCborStringEncoder'\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 { 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' || 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        // 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        // 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    // Check output size\n    ctx.bytesWritten += result.length\n    if (ctx.bytesWritten > ctx.options.maxOutputSize) {\n      throw new Error('Encoded output exceeds maximum size')\n    }\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.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      bytesWritten: 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.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      bytesWritten: 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    // In canonical mode, sort entries by encoded key (unless using allEntries for byte-perfect)\n    if (ctx.options.canonical && !(map as any)[ALL_ENTRIES_SYMBOL]) {\n      entries.sort((a, b) => {\n        const keyA = encodeValue(a[0], { ...ctx, depth: ctx.depth + 1 })\n        const keyB = encodeValue(b[0], { ...ctx, depth: ctx.depth + 1 })\n        return compareBytes(keyA, keyB)\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    // Check output size\n    ctx.bytesWritten += result.length\n    if (ctx.bytesWritten > ctx.options.maxOutputSize) {\n      throw new Error('Encoded output exceeds maximum size')\n    }\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.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      bytesWritten: 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.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      bytesWritten: 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 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 (value === 0) return new Uint8Array([0x00, 0x00])\n    if (value === -0) return new Uint8Array([0x80, 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    let exp16: number\n    let mant16: number\n\n    if (exp64 < -14) {\n      // Subnormal or zero\n      exp16 = 0\n      mant16 = 0\n    } else if (exp64 > 15) {\n      // Overflow to infinity\n      exp16 = 31\n      mant16 = 0\n    } else {\n      // Normal number\n      exp16 = exp64 + 15\n      // Take top 10 bits of mantissa\n      mant16 = mant64 >> 42\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) || value === 0 || value === -0) {\n      return true\n    }\n\n    // Check range\n    const absValue = Math.abs(value)\n    if (absValue < 0.00006103515625 || 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) || value === 0 || 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 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  // 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    // 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      // Check if it's an integer\n      if (Number.isInteger(value) && 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"]}