@marcuspuchalla/nachos 0.1.0

package/dist/chunk-2HBCILJS.cjs

@@ -0,0 +1,2034 @@
+'use strict';
+
+var chunkPD72MVTX_cjs = require('./chunk-PD72MVTX.cjs');
+
+// src/parser/utils.ts
+var hexToBytes = (hex) => {
+  const bytes = hex.match(/.{1,2}/g);
+  if (!bytes) return new Uint8Array(0);
+  return new Uint8Array(bytes.map((byte) => parseInt(byte, 16)));
+};
+var bytesToHex = (bytes) => {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+var readByte = (buffer, offset) => {
+  if (offset >= buffer.length) {
+    throw new Error(`Offset ${offset} is out of bounds (buffer length: ${buffer.length})`);
+  }
+  const byte = buffer[offset];
+  if (byte === void 0) {
+    throw new Error(`Unexpected undefined byte at offset ${offset}`);
+  }
+  return byte;
+};
+var readUint = (buffer, offset, length) => {
+  if (length < 1 || length > 8) {
+    throw new Error(`Invalid length: ${length} (must be 1-8)`);
+  }
+  if (offset + length > buffer.length) {
+    throw new Error(`Cannot read ${length} bytes at offset ${offset} (buffer length: ${buffer.length})`);
+  }
+  let result = 0;
+  for (let i = 0; i < length; i++) {
+    result = result * 256 + readByte(buffer, offset + i);
+  }
+  return result;
+};
+var readBigUint = (buffer, offset, length) => {
+  if (length < 1 || length > 8) {
+    throw new Error(`Invalid length: ${length} (must be 1-8)`);
+  }
+  if (offset + length > buffer.length) {
+    throw new Error(`Cannot read ${length} bytes at offset ${offset} (buffer length: ${buffer.length})`);
+  }
+  let result = 0n;
+  for (let i = 0; i < length; i++) {
+    result = result * 256n + BigInt(readByte(buffer, offset + i));
+  }
+  return result;
+};
+var extractCborHeader = (initialByte) => {
+  return {
+    majorType: initialByte >> 5,
+    additionalInfo: initialByte & 31
+  };
+};
+function validateUtf8Strict(bytes) {
+  let i = 0;
+  while (i < bytes.length) {
+    const byte = bytes[i];
+    if (byte === void 0) {
+      throw new Error(`Unexpected undefined byte at position ${i}`);
+    }
+    if (byte === 192 || byte === 193 || byte >= 245) {
+      throw new Error(
+        `Invalid UTF-8 start byte 0x${byte.toString(16).padStart(2, "0")} at position ${i}`
+      );
+    }
+    if (byte < 128) {
+      i++;
+      continue;
+    }
+    if (byte >= 194 && byte <= 223) {
+      if (i + 1 >= bytes.length) {
+        throw new Error(`Incomplete UTF-8 sequence at position ${i}`);
+      }
+      const byte2 = bytes[i + 1];
+      if (byte2 === void 0) {
+        throw new Error(`Incomplete UTF-8 sequence at position ${i}`);
+      }
+      if ((byte2 & 192) !== 128) {
+        throw new Error(`Invalid UTF-8 continuation byte at position ${i + 1}`);
+      }
+      const codepoint = (byte & 31) << 6 | byte2 & 63;
+      if (codepoint < 128) {
+        throw new Error(
+          `Overlong UTF-8 encoding at position ${i}: U+${codepoint.toString(16).padStart(4, "0").toUpperCase()} encoded as 2 bytes (should be 1 byte)`
+        );
+      }
+      i += 2;
+      continue;
+    }
+    if (byte >= 224 && byte <= 239) {
+      if (i + 2 >= bytes.length) {
+        throw new Error(`Incomplete UTF-8 sequence at position ${i}`);
+      }
+      const byte2 = bytes[i + 1];
+      const byte3 = bytes[i + 2];
+      if (byte2 === void 0 || byte3 === void 0) {
+        throw new Error(`Incomplete UTF-8 sequence at position ${i}`);
+      }
+      if ((byte2 & 192) !== 128 || (byte3 & 192) !== 128) {
+        throw new Error(
+          `Invalid UTF-8 continuation byte at position ${i + 1} or ${i + 2}`
+        );
+      }
+      const codepoint = (byte & 15) << 12 | (byte2 & 63) << 6 | byte3 & 63;
+      if (codepoint < 2048) {
+        throw new Error(
+          `Overlong UTF-8 encoding at position ${i}: U+${codepoint.toString(16).padStart(4, "0").toUpperCase()} encoded as 3 bytes (should be 2 bytes or less)`
+        );
+      }
+      if (codepoint >= 55296 && codepoint <= 57343) {
+        throw new Error(
+          `Invalid UTF-8 surrogate codepoint U+${codepoint.toString(16).padStart(4, "0").toUpperCase()} at position ${i} (surrogates are not valid Unicode scalar values)`
+        );
+      }
+      i += 3;
+      continue;
+    }
+    if (byte >= 240 && byte <= 244) {
+      if (i + 3 >= bytes.length) {
+        throw new Error(`Incomplete UTF-8 sequence at position ${i}`);
+      }
+      const byte2 = bytes[i + 1];
+      const byte3 = bytes[i + 2];
+      const byte4 = bytes[i + 3];
+      if (byte2 === void 0 || byte3 === void 0 || byte4 === void 0) {
+        throw new Error(`Incomplete UTF-8 sequence at position ${i}`);
+      }
+      if ((byte2 & 192) !== 128 || (byte3 & 192) !== 128 || (byte4 & 192) !== 128) {
+        throw new Error(
+          `Invalid UTF-8 continuation byte at position ${i + 1}, ${i + 2}, or ${i + 3}`
+        );
+      }
+      const codepoint = (byte & 7) << 18 | (byte2 & 63) << 12 | (byte3 & 63) << 6 | byte4 & 63;
+      if (codepoint < 65536) {
+        throw new Error(
+          `Overlong UTF-8 encoding at position ${i}: U+${codepoint.toString(16).padStart(6, "0").toUpperCase()} encoded as 4 bytes (should be 3 bytes or less)`
+        );
+      }
+      if (codepoint > 1114111) {
+        throw new Error(
+          `UTF-8 codepoint U+${codepoint.toString(16).padStart(6, "0").toUpperCase()} exceeds maximum U+10FFFF at position ${i}`
+        );
+      }
+      i += 4;
+      continue;
+    }
+    throw new Error(
+      `Invalid UTF-8 byte 0x${byte.toString(16).padStart(2, "0")} at position ${i}`
+    );
+  }
+}
+function validateCanonicalInteger(value, ai) {
+  const v = typeof value === "bigint" ? value : BigInt(value);
+  if (v >= 0n && v <= 23n && ai !== Number(v)) {
+    throw new Error(
+      `Non-canonical integer: value ${v} must use AI ${v}, not AI ${ai}`
+    );
+  }
+  if (v >= 24n && v <= 255n && ai !== 24) {
+    throw new Error(
+      `Non-canonical integer: value ${v} must use AI 24 (1-byte), not AI ${ai}`
+    );
+  }
+  if (v >= 256n && v <= 65535n && ai !== 25) {
+    throw new Error(
+      `Non-canonical integer: value ${v} must use AI 25 (2-byte), not AI ${ai}`
+    );
+  }
+  if (v >= 65536n && v <= 4294967295n && ai !== 26) {
+    throw new Error(
+      `Non-canonical integer: value ${v} must use AI 26 (4-byte), not AI ${ai}`
+    );
+  }
+  if (v > 4294967295n && ai !== 27) {
+    throw new Error(
+      `Non-canonical integer: value ${v} must use AI 27 (8-byte), not AI ${ai}`
+    );
+  }
+}
+function compareBytes(a, b) {
+  if (!a || !b) {
+    throw new Error("compareBytes: arguments cannot be null or undefined");
+  }
+  if (a.length !== b.length) {
+    return a.length - b.length;
+  }
+  for (let i = 0; i < a.length; i++) {
+    const byteA = a[i];
+    const byteB = b[i];
+    if (byteA === void 0 || byteB === void 0) {
+      throw new Error(`Unexpected undefined byte at index ${i}`);
+    }
+    if (byteA !== byteB) {
+      return byteA - byteB;
+    }
+  }
+  return 0;
+}
+function serializeValueForComparison(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "boolean") return value.toString();
+  if (typeof value === "number") return `num:${value}`;
+  if (typeof value === "bigint") return `bigint:${value.toString()}`;
+  if (typeof value === "string") return `str:${value}`;
+  if (value instanceof Uint8Array) {
+    return `bytes:${Array.from(value).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+  }
+  if (Array.isArray(value)) {
+    return `array:[${value.map((v) => serializeValueForComparison(v)).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    if ("tag" in value && "value" in value) {
+      return `tag:${value.tag}:${serializeValueForComparison(value.value)}`;
+    }
+    const keys = Object.keys(value).sort();
+    const pairs = keys.map((k) => `${k}:${serializeValueForComparison(value[k])}`);
+    return `map:{${pairs.join(",")}}`;
+  }
+  return String(value);
+}
+function hasDuplicates(items) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const serialized = serializeValueForComparison(item);
+    if (seen.has(serialized)) {
+      return true;
+    }
+    seen.add(serialized);
+  }
+  return false;
+}
+
+// src/parser/composables/useCborInteger.ts
+function useCborInteger() {
+  const parseInteger = (hexString, options) => {
+    const buffer = hexToBytes(hexString);
+    const initialByte = readByte(buffer, 0);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    let rawValue;
+    let bytesRead;
+    if (additionalInfo < 24) {
+      rawValue = additionalInfo;
+      bytesRead = 1;
+    } else if (additionalInfo === 24) {
+      rawValue = readByte(buffer, 1);
+      bytesRead = 2;
+    } else if (additionalInfo === 25) {
+      rawValue = readUint(buffer, 1, 2);
+      bytesRead = 3;
+    } else if (additionalInfo === 26) {
+      rawValue = readUint(buffer, 1, 4);
+      bytesRead = 5;
+    } else if (additionalInfo === 27) {
+      const bigValue = readBigUint(buffer, 1, 8);
+      if (bigValue <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        rawValue = Number(bigValue);
+      } else {
+        rawValue = bigValue;
+      }
+      bytesRead = 9;
+    } else {
+      throw new Error(`Invalid additional info: ${additionalInfo}`);
+    }
+    if (options?.validateCanonical) {
+      validateCanonicalInteger(rawValue, additionalInfo);
+    }
+    let finalValue;
+    if (majorType === 0) {
+      finalValue = rawValue;
+    } else if (majorType === 1) {
+      if (typeof rawValue === "bigint") {
+        const negValue = -1n - rawValue;
+        if (negValue >= BigInt(Number.MIN_SAFE_INTEGER) && negValue <= BigInt(Number.MAX_SAFE_INTEGER)) {
+          finalValue = Number(negValue);
+        } else {
+          finalValue = negValue;
+        }
+      } else {
+        const negValue = -1 - rawValue;
+        if (negValue >= Number.MIN_SAFE_INTEGER) {
+          finalValue = negValue;
+        } else {
+          finalValue = BigInt(negValue);
+        }
+      }
+    } else {
+      throw new Error(`Expected major type 0 or 1, got ${majorType}`);
+    }
+    return {
+      value: finalValue,
+      bytesRead
+    };
+  };
+  return {
+    parseInteger
+  };
+}
+
+// src/parser/composables/useCborString.ts
+function useCborString() {
+  const { create: createByteString } = chunkPD72MVTX_cjs.useCborByteString();
+  const { create: createTextString } = chunkPD72MVTX_cjs.useCborTextString();
+  const parseLength = (buffer, offset, ai, options) => {
+    if (ai < 24) {
+      return { length: ai, bytesConsumed: 0 };
+    } else if (ai === 24) {
+      const length = readByte(buffer, offset);
+      if (options?.validateCanonical && length < 24) {
+        throw new Error(`Non-canonical length encoding: ${length} should use direct encoding (AI < 24), not AI=24`);
+      }
+      return { length, bytesConsumed: 1 };
+    } else if (ai === 25) {
+      const length = readUint(buffer, offset, 2);
+      if (options?.validateCanonical && length < 256) {
+        throw new Error(`Non-canonical length encoding: ${length} should use ${length < 24 ? "direct encoding" : "1-byte encoding (AI=24)"}, not AI=25`);
+      }
+      return { length, bytesConsumed: 2 };
+    } else if (ai === 26) {
+      const length = readUint(buffer, offset, 4);
+      if (options?.validateCanonical && length < 65536) {
+        throw new Error(`Non-canonical length encoding: ${length} should use shorter encoding, not AI=26`);
+      }
+      return { length, bytesConsumed: 4 };
+    } else if (ai === 27) {
+      const lengthBigInt = readBigUint(buffer, offset, 8);
+      if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error(`String length ${lengthBigInt} exceeds maximum safe integer`);
+      }
+      const length = Number(lengthBigInt);
+      if (options?.validateCanonical && length < 4294967296) {
+        throw new Error(`Non-canonical length encoding: ${length} should use shorter encoding, not AI=27`);
+      }
+      return { length, bytesConsumed: 8 };
+    } else if (ai === 31) {
+      return { length: -1, bytesConsumed: 0 };
+    } else {
+      throw new Error(`Invalid additional info: ${ai}`);
+    }
+  };
+  const parseByteString = (buffer, offset = 0, options) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 2) {
+      throw new Error(`Expected major type 2 (byte string), got ${majorType}`);
+    }
+    if (additionalInfo === 31 && options?.allowIndefinite === false) {
+      throw new Error("Indefinite-length encoding is not allowed in strict mode");
+    }
+    const { length, bytesConsumed } = parseLength(buffer, offset + 1, additionalInfo, options);
+    if (length === -1) {
+      const chunks = [];
+      let currentOffset = offset + 1 + bytesConsumed;
+      let totalLength = 0;
+      while (currentOffset < buffer.length) {
+        if (currentOffset >= buffer.length) {
+          throw new Error(`Incomplete indefinite byte string: missing break marker`);
+        }
+        const nextByte = buffer[currentOffset];
+        if (nextByte === 255) {
+          currentOffset++;
+          break;
+        }
+        let chunkResult;
+        try {
+          chunkResult = parseByteString(buffer, currentOffset, options);
+        } catch (error2) {
+          throw new Error(`Error parsing indefinite byte string chunk at offset ${currentOffset}: ${error2.message}`);
+        }
+        if (!(chunkResult.value instanceof Uint8Array)) {
+          throw new Error("Indefinite byte string must contain only byte string chunks");
+        }
+        chunks.push(chunkResult.value);
+        totalLength += chunkResult.value.length;
+        currentOffset += chunkResult.bytesRead;
+        if (options?.limits?.maxStringLength && totalLength > options.limits.maxStringLength) {
+          throw new Error(`Byte string length ${totalLength} exceeds limit of ${options.limits.maxStringLength} bytes`);
+        }
+      }
+      const bytes = new Uint8Array(totalLength);
+      let destOffset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, destOffset);
+        destOffset += chunk.length;
+      }
+      return {
+        value: createByteString(bytes, true, chunks),
+        bytesRead: currentOffset - offset
+      };
+    }
+    if (options?.limits?.maxStringLength && length > options.limits.maxStringLength) {
+      throw new Error(`Byte string length ${length} exceeds limit of ${options.limits.maxStringLength} bytes`);
+    }
+    const payloadOffset = offset + 1 + bytesConsumed;
+    if (payloadOffset + length > buffer.length) {
+      throw new Error(`Insufficient data: expected ${length} bytes at offset ${payloadOffset}, but only ${buffer.length - payloadOffset} bytes available`);
+    }
+    const payload = buffer.slice(payloadOffset, payloadOffset + length);
+    return {
+      value: payload,
+      bytesRead: 1 + bytesConsumed + length
+    };
+  };
+  const parseTextString = (buffer, offset = 0, options) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 3) {
+      throw new Error(`Expected major type 3 (text string), got ${majorType}`);
+    }
+    if (additionalInfo === 31 && options?.allowIndefinite === false) {
+      throw new Error("Indefinite-length encoding is not allowed in strict mode");
+    }
+    const { length, bytesConsumed } = parseLength(buffer, offset + 1, additionalInfo, options);
+    if (length === -1) {
+      const chunks = [];
+      let currentOffset = offset + 1 + bytesConsumed;
+      let totalLength = 0;
+      while (currentOffset < buffer.length) {
+        if (currentOffset >= buffer.length) {
+          throw new Error(`Incomplete indefinite text string: missing break marker`);
+        }
+        const nextByte = buffer[currentOffset];
+        if (nextByte === 255) {
+          currentOffset++;
+          break;
+        }
+        let chunkResult;
+        try {
+          chunkResult = parseTextString(buffer, currentOffset, options);
+        } catch (error2) {
+          throw new Error(`Error parsing indefinite text string chunk at offset ${currentOffset}: ${error2.message}`);
+        }
+        if (typeof chunkResult.value !== "string") {
+          throw new Error("Indefinite text string must contain only text string chunks");
+        }
+        chunks.push(chunkResult.value);
+        totalLength += chunkResult.value.length;
+        currentOffset += chunkResult.bytesRead;
+        if (options?.limits?.maxStringLength && totalLength > options.limits.maxStringLength) {
+          throw new Error(`Text string length ${totalLength} exceeds limit of ${options.limits.maxStringLength} characters`);
+        }
+      }
+      const text2 = chunks.join("");
+      return {
+        value: createTextString(text2, true, chunks),
+        bytesRead: currentOffset - offset
+      };
+    }
+    if (options?.limits?.maxStringLength && length > options.limits.maxStringLength) {
+      throw new Error(`Text string length ${length} bytes exceeds limit of ${options.limits.maxStringLength} bytes`);
+    }
+    const payloadOffset = offset + 1 + bytesConsumed;
+    if (payloadOffset + length > buffer.length) {
+      throw new Error(`Insufficient data: expected ${length} bytes at offset ${payloadOffset}, but only ${buffer.length - payloadOffset} bytes available`);
+    }
+    const payload = buffer.slice(payloadOffset, payloadOffset + length);
+    if (options?.validateUtf8Strict) {
+      validateUtf8Strict(payload);
+    }
+    const decoder = new TextDecoder("utf-8");
+    const text = decoder.decode(payload);
+    return {
+      value: text,
+      bytesRead: 1 + bytesConsumed + length
+    };
+  };
+  const parseString = (hexString, options) => {
+    const buffer = hexToBytes(hexString);
+    const initialByte = readByte(buffer, 0);
+    const { majorType } = extractCborHeader(initialByte);
+    if (majorType === 2) {
+      return parseByteString(buffer, 0, options);
+    } else if (majorType === 3) {
+      return parseTextString(buffer, 0, options);
+    } else {
+      throw new Error(`Expected major type 2 or 3 (string), got ${majorType}`);
+    }
+  };
+  return {
+    parseString,
+    parseByteString,
+    parseTextString
+  };
+}
+
+// src/parser/composables/useCborFloat.ts
+function useCborFloat() {
+  const float16ToFloat64 = (buffer, offset) => {
+    const byte1 = readByte(buffer, offset);
+    const byte2 = readByte(buffer, offset + 1);
+    const value = byte1 << 8 | byte2;
+    const sign = (value & 32768) >> 15;
+    const exponent = (value & 31744) >> 10;
+    const fraction = value & 1023;
+    if (exponent === 0) {
+      if (fraction === 0) {
+        return sign === 0 ? 0 : -0;
+      }
+      return (sign === 0 ? 1 : -1) * Math.pow(2, -14) * (fraction / 1024);
+    }
+    if (exponent === 31) {
+      if (fraction === 0) {
+        return sign === 0 ? Infinity : -Infinity;
+      }
+      return NaN;
+    }
+    return (sign === 0 ? 1 : -1) * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
+  };
+  const parseSimpleFromBuffer = (buffer, offset) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 7) {
+      throw new Error(`Expected major type 7 (simple/float), got ${majorType}`);
+    }
+    if (additionalInfo < 20) {
+      return {
+        value: { simpleValue: additionalInfo },
+        bytesRead: 1
+      };
+    }
+    switch (additionalInfo) {
+      case 20:
+        return { value: false, bytesRead: 1 };
+      case 21:
+        return { value: true, bytesRead: 1 };
+      case 22:
+        return { value: null, bytesRead: 1 };
+      case 23:
+        return { value: void 0, bytesRead: 1 };
+      case 24: {
+        if (offset + 1 >= buffer.length) {
+          throw new Error("Unexpected end of buffer while reading simple value");
+        }
+        const simpleValue = readByte(buffer, offset + 1);
+        if (simpleValue < 32) {
+          throw new Error(`Invalid 1-byte encoding for simple value ${simpleValue}`);
+        }
+        return {
+          value: { simpleValue },
+          bytesRead: 2
+        };
+      }
+      case 25:
+      // Float16
+      case 26:
+      // Float32
+      case 27:
+        throw new Error(`Additional info ${additionalInfo} is a float, use parseFloat instead`);
+      case 28:
+      case 29:
+      case 30:
+        throw new Error(`Reserved additional info value: ${additionalInfo}`);
+      case 31:
+        throw new Error("Break marker (0xff) should only appear in indefinite-length items");
+      default:
+        throw new Error(`Invalid additional info: ${additionalInfo}`);
+    }
+  };
+  const parseFloatFromBuffer = (buffer, offset) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 7) {
+      throw new Error(`Expected major type 7 (simple/float), got ${majorType}`);
+    }
+    switch (additionalInfo) {
+      case 25: {
+        if (offset + 2 >= buffer.length) {
+          throw new Error("Unexpected end of buffer while reading Float16");
+        }
+        const value = float16ToFloat64(buffer, offset + 1);
+        return { value, bytesRead: 3 };
+      }
+      case 26: {
+        if (offset + 4 >= buffer.length) {
+          throw new Error("Unexpected end of buffer while reading Float32");
+        }
+        const dataView = new DataView(buffer.buffer, buffer.byteOffset + offset + 1, 4);
+        const value = dataView.getFloat32(0, false);
+        return { value, bytesRead: 5 };
+      }
+      case 27: {
+        if (offset + 8 >= buffer.length) {
+          throw new Error("Unexpected end of buffer while reading Float64");
+        }
+        const dataView = new DataView(buffer.buffer, buffer.byteOffset + offset + 1, 8);
+        const value = dataView.getFloat64(0, false);
+        return { value, bytesRead: 9 };
+      }
+      default:
+        throw new Error(`Additional info ${additionalInfo} is not a float type`);
+    }
+  };
+  const parseFromBuffer = (buffer, offset) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 7) {
+      throw new Error(`Expected major type 7 (simple/float), got ${majorType}`);
+    }
+    if (additionalInfo === 25 || additionalInfo === 26 || additionalInfo === 27) {
+      return parseFloatFromBuffer(buffer, offset);
+    } else {
+      return parseSimpleFromBuffer(buffer, offset);
+    }
+  };
+  const parseSimple = (hexString, _options) => {
+    const buffer = hexToBytes(hexString);
+    return parseSimpleFromBuffer(buffer, 0);
+  };
+  const parseFloat = (hexString, _options) => {
+    const buffer = hexToBytes(hexString);
+    return parseFloatFromBuffer(buffer, 0);
+  };
+  const parse = (hexString, _options) => {
+    const buffer = hexToBytes(hexString);
+    return parseFromBuffer(buffer, 0);
+  };
+  return {
+    parse,
+    parseFloat,
+    parseSimple
+  };
+}
+
+// src/parser/composables/useCborTag.ts
+function useCborTag() {
+  const { parseInteger } = useCborInteger();
+  const { parseByteString, parseTextString } = useCborString();
+  const { parseFloat, parseSimple } = useCborFloat();
+  const parseItem = (buffer, offset, options, tagDepth = 0) => {
+    if (offset >= buffer.length) {
+      throw new Error(`Unexpected end of buffer at offset ${offset}`);
+    }
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    switch (majorType) {
+      case 0:
+      // Unsigned integer
+      case 1: {
+        const intHex = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+        const result = parseInteger(intHex, options);
+        return { value: result.value, bytesRead: result.bytesRead };
+      }
+      case 2:
+        return parseByteString(buffer, offset, options);
+      case 3:
+        return parseTextString(buffer, offset, options);
+      case 4:
+        return parseArrayInternal(buffer, offset, options);
+      case 5:
+        return parseMapInternal(buffer, offset, options);
+      case 6:
+        return parseTagFromBuffer(buffer, offset, options, tagDepth);
+      case 7: {
+        const simpleHex = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+        if (additionalInfo >= 25 && additionalInfo <= 27) {
+          const result = parseFloat(simpleHex, options);
+          return { value: result.value, bytesRead: result.bytesRead };
+        } else {
+          const result = parseSimple(simpleHex, options);
+          return { value: result.value, bytesRead: result.bytesRead };
+        }
+      }
+      default:
+        throw new Error(`Unknown major type: ${majorType}`);
+    }
+  };
+  const parseArrayInternal = (buffer, offset, options) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 4) {
+      throw new Error(`Expected major type 4 (array), got ${majorType}`);
+    }
+    let length;
+    let bytesConsumed;
+    if (additionalInfo < 24) {
+      length = additionalInfo;
+      bytesConsumed = 0;
+    } else if (additionalInfo === 24) {
+      length = readByte(buffer, offset + 1);
+      bytesConsumed = 1;
+    } else if (additionalInfo === 25) {
+      length = readUint(buffer, offset + 1, 2);
+      bytesConsumed = 2;
+    } else if (additionalInfo === 26) {
+      length = readUint(buffer, offset + 1, 4);
+      bytesConsumed = 4;
+    } else if (additionalInfo === 27) {
+      const lengthBigInt = readBigUint(buffer, offset + 1, 8);
+      if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error(`Array length ${lengthBigInt} exceeds maximum safe integer`);
+      }
+      length = Number(lengthBigInt);
+      bytesConsumed = 8;
+    } else if (additionalInfo === 31) {
+      length = null;
+      bytesConsumed = 0;
+    } else {
+      throw new Error(`Invalid additional info for array: ${additionalInfo}`);
+    }
+    let currentOffset = offset + 1 + bytesConsumed;
+    const items = [];
+    if (length === null) {
+      while (currentOffset < buffer.length) {
+        const nextByte = readByte(buffer, currentOffset);
+        if (nextByte === 255) {
+          currentOffset++;
+          break;
+        }
+        const itemResult = parseItem(buffer, currentOffset, options);
+        items.push(itemResult.value);
+        currentOffset += itemResult.bytesRead;
+      }
+      items[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] = true;
+    } else {
+      for (let i = 0; i < length; i++) {
+        const itemResult = parseItem(buffer, currentOffset, options);
+        items.push(itemResult.value);
+        currentOffset += itemResult.bytesRead;
+      }
+    }
+    return {
+      value: items,
+      bytesRead: currentOffset - offset
+    };
+  };
+  const parseMapInternal = (buffer, offset, options) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 5) {
+      throw new Error(`Expected major type 5 (map), got ${majorType}`);
+    }
+    let length;
+    let bytesConsumed;
+    if (additionalInfo < 24) {
+      length = additionalInfo;
+      bytesConsumed = 0;
+    } else if (additionalInfo === 24) {
+      length = readByte(buffer, offset + 1);
+      bytesConsumed = 1;
+    } else if (additionalInfo === 25) {
+      length = readUint(buffer, offset + 1, 2);
+      bytesConsumed = 2;
+    } else if (additionalInfo === 26) {
+      length = readUint(buffer, offset + 1, 4);
+      bytesConsumed = 4;
+    } else if (additionalInfo === 27) {
+      const lengthBigInt = readBigUint(buffer, offset + 1, 8);
+      if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error(`Map length ${lengthBigInt} exceeds maximum safe integer`);
+      }
+      length = Number(lengthBigInt);
+      bytesConsumed = 8;
+    } else if (additionalInfo === 31) {
+      length = null;
+      bytesConsumed = 0;
+    } else {
+      throw new Error(`Invalid additional info for map: ${additionalInfo}`);
+    }
+    let currentOffset = offset + 1 + bytesConsumed;
+    const map = /* @__PURE__ */ new Map();
+    if (length === null) {
+      while (currentOffset < buffer.length) {
+        const nextByte = readByte(buffer, currentOffset);
+        if (nextByte === 255) {
+          currentOffset++;
+          break;
+        }
+        const keyResult = parseItem(buffer, currentOffset, options);
+        currentOffset += keyResult.bytesRead;
+        const valueResult = parseItem(buffer, currentOffset, options);
+        currentOffset += valueResult.bytesRead;
+        map.set(keyResult.value, valueResult.value);
+      }
+      map[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] = true;
+    } else {
+      for (let i = 0; i < length; i++) {
+        const keyResult = parseItem(buffer, currentOffset, options);
+        currentOffset += keyResult.bytesRead;
+        const valueResult = parseItem(buffer, currentOffset, options);
+        currentOffset += valueResult.bytesRead;
+        map.set(keyResult.value, valueResult.value);
+      }
+    }
+    return {
+      value: map,
+      bytesRead: currentOffset - offset
+    };
+  };
+  const parseTagNumber = (buffer, offset, ai) => {
+    if (ai < 24) {
+      return { tagNumber: ai, bytesConsumed: 0 };
+    } else if (ai === 24) {
+      const tagNumber = readByte(buffer, offset);
+      return { tagNumber, bytesConsumed: 1 };
+    } else if (ai === 25) {
+      const tagNumber = readUint(buffer, offset, 2);
+      return { tagNumber, bytesConsumed: 2 };
+    } else if (ai === 26) {
+      const tagNumber = readUint(buffer, offset, 4);
+      return { tagNumber, bytesConsumed: 4 };
+    } else if (ai === 27) {
+      const tagBigInt = readBigUint(buffer, offset, 8);
+      if (tagBigInt <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        return { tagNumber: Number(tagBigInt), bytesConsumed: 8 };
+      } else {
+        throw new Error(`Tag number ${tagBigInt} exceeds maximum safe integer`);
+      }
+    } else if (ai >= 28 && ai <= 30) {
+      throw new Error(`Reserved additional info ${ai} for major type 6`);
+    } else {
+      throw new Error(`Invalid additional info ${ai} for tags`);
+    }
+  };
+  const isValidRfc3339 = (dateStr) => {
+    const rfc3339Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$/i;
+    return rfc3339Regex.test(dateStr);
+  };
+  const isValidUri = (uri) => {
+    const uriRegex = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+    return uriRegex.test(uri);
+  };
+  const isTextString = (value) => {
+    if (typeof value === "string") return true;
+    if (value && typeof value === "object" && "type" in value && value.type === "cbor-text-string") {
+      return true;
+    }
+    return false;
+  };
+  const getTextStringValue = (value) => {
+    if (typeof value === "string") return value;
+    if (value && typeof value === "object" && "text" in value) {
+      return value.text;
+    }
+    return String(value);
+  };
+  const validateTagSemantics = (tagNumber, value, options) => {
+    const shouldValidateStandard = options?.strict || options?.validateTagSemantics;
+    switch (tagNumber) {
+      case 0:
+        if (!shouldValidateStandard) break;
+        if (!isTextString(value)) {
+          throw new Error(`Tag 0 (date/time string) must contain a text string, got ${typeof value}`);
+        }
+        const dateStr = getTextStringValue(value);
+        if (!isValidRfc3339(dateStr)) {
+          throw new Error(`Tag 0 (date/time string) contains invalid RFC 3339 date format: "${dateStr}"`);
+        }
+        break;
+      case 1:
+        if (!shouldValidateStandard) break;
+        if (typeof value !== "number" && typeof value !== "bigint") {
+          throw new Error(`Tag 1 (epoch time) must contain a number (integer or float), got ${typeof value}`);
+        }
+        break;
+      case 4:
+        if (!shouldValidateStandard) break;
+        if (!Array.isArray(value)) {
+          throw new Error(`Tag 4 (decimal fraction) must contain an array, got ${typeof value}`);
+        }
+        if (value.length !== 2) {
+          throw new Error(`Tag 4 (decimal fraction) array must have exactly 2 elements [exponent, mantissa], got ${value.length}`);
+        }
+        if (typeof value[0] !== "number" && typeof value[0] !== "bigint") {
+          throw new Error(`Tag 4 (decimal fraction) exponent must be an integer, got ${typeof value[0]}`);
+        }
+        if (typeof value[1] !== "number" && typeof value[1] !== "bigint") {
+          throw new Error(`Tag 4 (decimal fraction) mantissa must be an integer, got ${typeof value[1]}`);
+        }
+        break;
+      case 5:
+        if (!shouldValidateStandard) break;
+        if (!Array.isArray(value)) {
+          throw new Error(`Tag 5 (bigfloat) must contain an array, got ${typeof value}`);
+        }
+        if (value.length !== 2) {
+          throw new Error(`Tag 5 (bigfloat) array must have exactly 2 elements [exponent, mantissa], got ${value.length}`);
+        }
+        if (typeof value[0] !== "number" && typeof value[0] !== "bigint") {
+          throw new Error(`Tag 5 (bigfloat) exponent must be an integer, got ${typeof value[0]}`);
+        }
+        if (typeof value[1] !== "number" && typeof value[1] !== "bigint") {
+          throw new Error(`Tag 5 (bigfloat) mantissa must be an integer, got ${typeof value[1]}`);
+        }
+        break;
+      case 32:
+        if (!shouldValidateStandard) break;
+        if (!isTextString(value)) {
+          throw new Error(`Tag 32 (URI) must contain a text string, got ${typeof value}`);
+        }
+        const uriStr = getTextStringValue(value);
+        if (!isValidUri(uriStr)) {
+          throw new Error(`Tag 32 (URI) contains invalid URI format (missing scheme): "${uriStr}"`);
+        }
+        break;
+      case 33:
+      // base64url without padding
+      case 34:
+        if (!shouldValidateStandard) break;
+        if (!isTextString(value)) {
+          throw new Error(`Tag ${tagNumber} (base64${tagNumber === 33 ? "url" : ""}) must contain a text string, got ${typeof value}`);
+        }
+        break;
+      case 35:
+        if (!shouldValidateStandard) break;
+        if (!isTextString(value)) {
+          throw new Error(`Tag 35 (regexp) must contain a text string, got ${typeof value}`);
+        }
+        break;
+      case 36:
+        if (!shouldValidateStandard) break;
+        if (!isTextString(value)) {
+          throw new Error(`Tag 36 (MIME message) must contain a text string, got ${typeof value}`);
+        }
+        break;
+      case 258:
+        {
+          const shouldValidateUniqueness = options?.strict || options?.validateSetUniqueness;
+          if (shouldValidateUniqueness) {
+            if (!Array.isArray(value)) {
+              throw new Error(`Tag 258 (set) must contain an array, got ${typeof value}`);
+            }
+            if (hasDuplicates(value)) {
+              throw new Error(
+                `Tag 258 (set) contains duplicate items. Sets must contain only unique values (RFC 8949). Use validateSetUniqueness: false to allow duplicates.`
+              );
+            }
+          }
+        }
+        break;
+      // Plutus Constructor tags
+      case 102:
+        validatePlutusAlternativeConstructor(value, options);
+        break;
+      // No validation needed for other tags (yet)
+      default:
+        if (tagNumber >= 121 && tagNumber <= 127) {
+          validatePlutusCompactConstructor(tagNumber, value, options);
+        } else if (tagNumber >= 1280 && tagNumber <= 1400) {
+          validatePlutusExtendedConstructor(tagNumber, value, options);
+        }
+        break;
+    }
+  };
+  const validatePlutusCompactConstructor = (tagNumber, value, options) => {
+    const shouldValidate = options?.strict || options?.validatePlutusSemantics;
+    if (!shouldValidate) {
+      return;
+    }
+    if (!Array.isArray(value)) {
+      throw new Error(
+        `Plutus constructor tag ${tagNumber} must contain an array, got ${typeof value}`
+      );
+    }
+  };
+  const validatePlutusAlternativeConstructor = (value, options) => {
+    const shouldValidate = options?.strict || options?.validatePlutusSemantics;
+    if (!shouldValidate) {
+      return;
+    }
+    if (!Array.isArray(value)) {
+      throw new Error(
+        `Plutus alternative constructor (tag 102) must contain an array, got ${typeof value}`
+      );
+    }
+    if (value.length !== 2) {
+      throw new Error(
+        `Plutus alternative constructor (tag 102) must be [constructor_index, fields], got array of length ${value.length}`
+      );
+    }
+    const constructorIndex = value[0];
+    const fields = value[1];
+    if (typeof constructorIndex !== "number" || constructorIndex < 0 || !Number.isInteger(constructorIndex)) {
+      throw new Error(
+        `Plutus constructor index must be non-negative integer, got ${typeof constructorIndex}`
+      );
+    }
+    if (!Array.isArray(fields)) {
+      throw new Error(
+        `Plutus constructor fields must be an array, got ${typeof fields}`
+      );
+    }
+  };
+  const validatePlutusExtendedConstructor = (tagNumber, value, options) => {
+    const shouldValidate = options?.strict || options?.validatePlutusSemantics;
+    if (!shouldValidate) {
+      return;
+    }
+    if (!Array.isArray(value)) {
+      throw new Error(
+        `Plutus constructor tag ${tagNumber} must contain an array, got ${typeof value}`
+      );
+    }
+    const constructorIndex = tagNumber - 1280 + 7;
+    if (constructorIndex < 7 || constructorIndex > 127) {
+      throw new Error(
+        `Plutus extended constructor tag ${tagNumber} produces invalid constructor index ${constructorIndex} (expected 7-127)`
+      );
+    }
+  };
+  const decodePlutusConstructor = (tagNumber, value) => {
+    if (tagNumber === 102) {
+      if (!Array.isArray(value) || value.length !== 2) {
+        return null;
+      }
+      const [constructorIndex, fields] = value;
+      if (typeof constructorIndex !== "number" || !Array.isArray(fields)) {
+        return null;
+      }
+      return {
+        constructor: constructorIndex,
+        fields
+      };
+    }
+    if (tagNumber >= 121 && tagNumber <= 127) {
+      if (!Array.isArray(value)) {
+        return null;
+      }
+      const constructorIndex = tagNumber - 121;
+      return {
+        constructor: constructorIndex,
+        fields: value
+      };
+    }
+    if (tagNumber >= 1280 && tagNumber <= 1400) {
+      if (!Array.isArray(value)) {
+        return null;
+      }
+      const constructorIndex = tagNumber - 1280 + 7;
+      return {
+        constructor: constructorIndex,
+        fields: value
+      };
+    }
+    return null;
+  };
+  const parseTagFromBuffer = (buffer, offset, options, tagDepth = 0) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 6) {
+      throw new Error(`Expected major type 6 (tag), got ${majorType}`);
+    }
+    const maxTagDepth = options?.limits?.maxTagDepth ?? 64;
+    if (tagDepth >= maxTagDepth) {
+      throw new Error(`Tag nesting depth ${tagDepth} exceeds limit of ${maxTagDepth}`);
+    }
+    const { tagNumber, bytesConsumed } = parseTagNumber(buffer, offset + 1, additionalInfo);
+    let currentOffset = offset + 1 + bytesConsumed;
+    if (currentOffset >= buffer.length) {
+      throw new Error(`Unexpected end of buffer after tag ${tagNumber}`);
+    }
+    const valueResult = parseItem(buffer, currentOffset, options, tagDepth + 1);
+    currentOffset += valueResult.bytesRead;
+    if ((tagNumber === 2 || tagNumber === 3) && valueResult.value instanceof Uint8Array) {
+      const maxBignumBytes = options?.limits?.maxBignumBytes ?? 1024;
+      if (valueResult.value.length > maxBignumBytes) {
+        throw new Error(
+          `Bignum (tag ${tagNumber}) size ${valueResult.value.length} bytes exceeds limit of ${maxBignumBytes} bytes`
+        );
+      }
+      const bytes = valueResult.value;
+      let bigintValue = 0n;
+      for (let i = 0; i < bytes.length; i++) {
+        bigintValue = bigintValue << 8n | BigInt(bytes[i]);
+      }
+      if (tagNumber === 2) {
+        valueResult.value = bigintValue;
+      } else if (tagNumber === 3) {
+        valueResult.value = -1n - bigintValue;
+      }
+    }
+    validateTagSemantics(tagNumber, valueResult.value, options);
+    const plutusConstr = decodePlutusConstructor(tagNumber, valueResult.value);
+    const taggedValue = {
+      tag: tagNumber,
+      value: valueResult.value,
+      ...plutusConstr && { plutus: plutusConstr }
+    };
+    return {
+      value: taggedValue,
+      bytesRead: currentOffset - offset
+    };
+  };
+  const parseTag = (hexString, options) => {
+    const cleanHex = hexString.replace(/\s+/g, "");
+    const buffer = hexToBytes(cleanHex);
+    return parseTagFromBuffer(buffer, 0, options);
+  };
+  const parse = parseTag;
+  return {
+    parseTag,
+    parse
+  };
+}
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+var config = {
+  level: "warn",
+  prefix: "[CBOR]"
+};
+function configureLogger(newConfig) {
+  config = { ...config, ...newConfig };
+}
+function getLoggerConfig() {
+  return { ...config };
+}
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[config.level];
+}
+function formatMessage(message) {
+  return config.prefix ? `${config.prefix} ${message}` : message;
+}
+function debug(message, ...args) {
+  if (shouldLog("debug")) {
+    console.debug(formatMessage(message), ...args);
+  }
+}
+function info(message, ...args) {
+  if (shouldLog("info")) {
+    console.info(formatMessage(message), ...args);
+  }
+}
+function warn(message, ...args) {
+  if (shouldLog("warn")) {
+    console.warn(formatMessage(message), ...args);
+  }
+}
+function error(message, ...args) {
+  if (shouldLog("error")) {
+    console.error(formatMessage(message), ...args);
+  }
+}
+var logger = {
+  debug,
+  info,
+  warn,
+  error,
+  configure: configureLogger,
+  getConfig: getLoggerConfig
+};
+
+// src/parser/composables/useCborCollection.ts
+function useCborCollection() {
+  const { parseInteger } = useCborInteger();
+  const { parseByteString, parseTextString } = useCborString();
+  const { parse: parseFloatOrSimple } = useCborFloat();
+  const { parseTag } = useCborTag();
+  const convertKeyToString = (key) => {
+    if (key instanceof Uint8Array) {
+      return bytesToHex(key);
+    }
+    return String(key);
+  };
+  const parseItem = (buffer, offset, options, depth = 0) => {
+    if (offset >= buffer.length) {
+      throw new Error(`Unexpected end of buffer at offset ${offset}`);
+    }
+    const initialByte = readByte(buffer, offset);
+    const { majorType } = extractCborHeader(initialByte);
+    switch (majorType) {
+      case 0:
+      // Unsigned integer
+      case 1: {
+        const intHex = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+        const result = parseInteger(intHex, options);
+        return { value: result.value, bytesRead: result.bytesRead };
+      }
+      case 2:
+        return parseByteString(buffer, offset, options);
+      case 3:
+        return parseTextString(buffer, offset, options);
+      case 4:
+        return parseArrayFromBuffer(buffer, offset, options, depth);
+      case 5:
+        return parseMapFromBuffer(buffer, offset, options, depth);
+      case 6: {
+        const tagHex = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+        const result = parseTag(tagHex, options);
+        return { value: result.value, bytesRead: result.bytesRead };
+      }
+      case 7: {
+        const floatHex = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+        const result = parseFloatOrSimple(floatHex, options);
+        return { value: result.value, bytesRead: result.bytesRead };
+      }
+      default:
+        throw new Error(`Unknown major type: ${majorType}`);
+    }
+  };
+  const parseLength = (buffer, offset, ai, options) => {
+    if (ai < 24) {
+      return { length: ai, bytesConsumed: 0 };
+    } else if (ai === 24) {
+      const length = readByte(buffer, offset);
+      if (options?.validateCanonical && length < 24) {
+        throw new Error(`Non-canonical length encoding: ${length} should use direct encoding (AI < 24), not AI=24`);
+      }
+      return { length, bytesConsumed: 1 };
+    } else if (ai === 25) {
+      const length = readUint(buffer, offset, 2);
+      if (options?.validateCanonical && length < 256) {
+        throw new Error(`Non-canonical length encoding: ${length} should use ${length < 24 ? "direct encoding" : "1-byte encoding (AI=24)"}, not AI=25`);
+      }
+      return { length, bytesConsumed: 2 };
+    } else if (ai === 26) {
+      const length = readUint(buffer, offset, 4);
+      if (options?.validateCanonical && length < 65536) {
+        throw new Error(`Non-canonical length encoding: ${length} should use shorter encoding, not AI=26`);
+      }
+      return { length, bytesConsumed: 4 };
+    } else if (ai === 27) {
+      const lengthBigInt = readBigUint(buffer, offset, 8);
+      if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error(`Collection length ${lengthBigInt} exceeds maximum safe integer`);
+      }
+      const length = Number(lengthBigInt);
+      if (options?.validateCanonical && length < 4294967296) {
+        throw new Error(`Non-canonical length encoding: ${length} should use shorter encoding, not AI=27`);
+      }
+      return { length, bytesConsumed: 8 };
+    } else if (ai === 31) {
+      return { length: null, bytesConsumed: 0 };
+    } else {
+      throw new Error(`Invalid additional info: ${ai}`);
+    }
+  };
+  const parseArrayFromBuffer = (buffer, offset, options, depth = 0) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 4) {
+      throw new Error(`Expected major type 4 (array), got ${majorType}`);
+    }
+    const isIndefiniteAllowed = options?.allowIndefinite ?? !(options?.validateCanonical || options?.strict);
+    if (additionalInfo === 31 && !isIndefiniteAllowed) {
+      throw new Error("Indefinite-length encoding is not allowed (strict/canonical mode)");
+    }
+    if (options?.limits?.maxDepth && depth >= options.limits.maxDepth) {
+      throw new Error(`Maximum nesting depth ${options.limits.maxDepth} exceeded`);
+    }
+    const { length, bytesConsumed } = parseLength(buffer, offset + 1, additionalInfo, options);
+    let currentOffset = offset + 1 + bytesConsumed;
+    const items = [];
+    if (length === null) {
+      let index = 0;
+      let foundBreak = false;
+      while (currentOffset < buffer.length) {
+        const nextByte = readByte(buffer, currentOffset);
+        if (nextByte === 255) {
+          currentOffset++;
+          foundBreak = true;
+          break;
+        }
+        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, depth + 1);
+        items.push(itemResult.value);
+        currentOffset += itemResult.bytesRead;
+        index++;
+      }
+      if (!foundBreak) {
+        throw new Error("Indefinite-length array missing break code (0xFF)");
+      }
+      items[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] = true;
+    } else {
+      if (options?.limits?.maxArrayLength && length > options.limits.maxArrayLength) {
+        throw new Error(`Array length ${length} exceeds limit of ${options.limits.maxArrayLength}`);
+      }
+      for (let i = 0; i < length; i++) {
+        if (currentOffset >= buffer.length) {
+          throw new Error(`Unexpected end of buffer while parsing array element ${i}/${length}`);
+        }
+        const itemResult = parseItem(buffer, currentOffset, options, depth + 1);
+        items.push(itemResult.value);
+        currentOffset += itemResult.bytesRead;
+      }
+    }
+    return {
+      value: items,
+      bytesRead: currentOffset - offset
+    };
+  };
+  const parseMapFromBuffer = (buffer, offset, options, depth = 0) => {
+    const initialByte = readByte(buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    if (majorType !== 5) {
+      throw new Error(`Expected major type 5 (map), got ${majorType}`);
+    }
+    const isIndefiniteAllowed = options?.allowIndefinite ?? !(options?.validateCanonical || options?.strict);
+    if (additionalInfo === 31 && !isIndefiniteAllowed) {
+      throw new Error("Indefinite-length encoding is not allowed (strict/canonical mode)");
+    }
+    if (options?.limits?.maxDepth && depth >= options.limits.maxDepth) {
+      throw new Error(`Maximum nesting depth ${options.limits.maxDepth} exceeded`);
+    }
+    const { length, bytesConsumed } = parseLength(buffer, offset + 1, additionalInfo, options);
+    let currentOffset = offset + 1 + bytesConsumed;
+    const map = /* @__PURE__ */ new Map();
+    const seenKeys = /* @__PURE__ */ new Set();
+    const keyBytes = [];
+    const allEntries = [];
+    if (length === null) {
+      let index = 0;
+      let foundBreak = false;
+      while (currentOffset < buffer.length) {
+        const nextByte = readByte(buffer, currentOffset);
+        if (nextByte === 255) {
+          currentOffset++;
+          foundBreak = true;
+          break;
+        }
+        if (options?.limits?.maxMapSize && index >= options.limits.maxMapSize) {
+          throw new Error(`Map size exceeds limit of ${options.limits.maxMapSize}`);
+        }
+        const keyStart = currentOffset;
+        const keyResult = parseItem(buffer, currentOffset, options, depth + 1);
+        const keyEnd = currentOffset + keyResult.bytesRead;
+        currentOffset += keyResult.bytesRead;
+        if (options?.validateCanonical) {
+          keyBytes.push(buffer.slice(keyStart, keyEnd));
+        }
+        if (currentOffset >= buffer.length) {
+          throw new Error("Unexpected end of buffer while parsing map value");
+        }
+        const valueResult = parseItem(buffer, currentOffset, options, depth + 1);
+        currentOffset += valueResult.bytesRead;
+        const keyString = convertKeyToString(keyResult.value);
+        if (seenKeys.has(keyString)) {
+          const mode = options?.dupMapKeyMode || "allow";
+          if (mode === "reject") {
+            throw new Error(`Duplicate map key detected: ${keyString} at offset ${keyStart}`);
+          } else if (mode === "warn") {
+            logger.warn(`Duplicate map key detected: ${keyString} at offset ${keyStart}`);
+          }
+        }
+        seenKeys.add(keyString);
+        map.set(keyResult.value, valueResult.value);
+        allEntries.push([keyResult.value, valueResult.value]);
+        index++;
+      }
+      if (!foundBreak) {
+        throw new Error("Indefinite-length map missing break code (0xFF)");
+      }
+      map[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] = true;
+    } else {
+      if (options?.limits?.maxMapSize && length > options.limits.maxMapSize) {
+        throw new Error(`Map size ${length} exceeds limit of ${options.limits.maxMapSize}`);
+      }
+      for (let i = 0; i < length; i++) {
+        if (currentOffset >= buffer.length) {
+          throw new Error(`Unexpected end of buffer while parsing map entry ${i}/${length}`);
+        }
+        const keyStart = currentOffset;
+        const keyResult = parseItem(buffer, currentOffset, options, depth + 1);
+        const keyEnd = currentOffset + keyResult.bytesRead;
+        currentOffset += keyResult.bytesRead;
+        if (options?.validateCanonical) {
+          keyBytes.push(buffer.slice(keyStart, keyEnd));
+        }
+        if (currentOffset >= buffer.length) {
+          throw new Error(`Unexpected end of buffer while parsing map value for entry ${i}/${length}`);
+        }
+        const valueResult = parseItem(buffer, currentOffset, options, depth + 1);
+        currentOffset += valueResult.bytesRead;
+        const keyString = convertKeyToString(keyResult.value);
+        if (seenKeys.has(keyString)) {
+          const mode = options?.dupMapKeyMode || "allow";
+          if (mode === "reject") {
+            throw new Error(`Duplicate map key detected: ${keyString} at offset ${keyStart}`);
+          } else if (mode === "warn") {
+            logger.warn(`Duplicate map key detected: ${keyString} at offset ${keyStart}`);
+          }
+        }
+        seenKeys.add(keyString);
+        map.set(keyResult.value, valueResult.value);
+        allEntries.push([keyResult.value, valueResult.value]);
+      }
+    }
+    map[chunkPD72MVTX_cjs.ALL_ENTRIES_SYMBOL] = allEntries;
+    if (options?.validateCanonical && keyBytes.length > 1) {
+      for (let i = 1; i < keyBytes.length; i++) {
+        const prevKey = keyBytes[i - 1];
+        const currKey = keyBytes[i];
+        if (prevKey && currKey) {
+          const cmp = compareBytes(prevKey, currKey);
+          if (cmp > 0) {
+            throw new Error(
+              `Map keys are not in canonical order: key at index ${i} should come before key at index ${i - 1}`
+            );
+          }
+          if (cmp === 0) {
+            throw new Error(`Duplicate map keys detected in canonical validation`);
+          }
+        }
+      }
+    }
+    return {
+      value: map,
+      bytesRead: currentOffset - offset
+    };
+  };
+  const parseArray = (hexString, options) => {
+    const cleanHex = hexString.replace(/\s+/g, "");
+    const buffer = hexToBytes(cleanHex);
+    return parseArrayFromBuffer(buffer, 0, options, 0);
+  };
+  const parseMap = (hexString, options) => {
+    const cleanHex = hexString.replace(/\s+/g, "");
+    const buffer = hexToBytes(cleanHex);
+    return parseMapFromBuffer(buffer, 0, options, 0);
+  };
+  return {
+    parseArray,
+    parseMap
+  };
+}
+
+// src/parser/composables/useCborParser.ts
+function useCborParser() {
+  const mergeOptions = (options) => {
+    if (!options) return chunkPD72MVTX_cjs.DEFAULT_OPTIONS;
+    const isCanonical = options.validateCanonical ?? (options.strict ? true : false);
+    return {
+      strict: options.strict ?? chunkPD72MVTX_cjs.DEFAULT_OPTIONS.strict,
+      validateCanonical: isCanonical,
+      // RFC 8949 Section 4.2: Deterministic encoding MUST NOT use indefinite-length
+      allowIndefinite: options.allowIndefinite ?? (isCanonical || options.strict ? false : chunkPD72MVTX_cjs.DEFAULT_OPTIONS.allowIndefinite),
+      // Auto-enable duplicate key rejection for canonical or strict mode
+      dupMapKeyMode: options.dupMapKeyMode ?? (isCanonical || options.strict ? "reject" : chunkPD72MVTX_cjs.DEFAULT_OPTIONS.dupMapKeyMode),
+      validateUtf8Strict: options.validateUtf8Strict ?? (options.strict ? true : chunkPD72MVTX_cjs.DEFAULT_OPTIONS.validateUtf8Strict),
+      validateSetUniqueness: options.validateSetUniqueness ?? (options.strict ? true : chunkPD72MVTX_cjs.DEFAULT_OPTIONS.validateSetUniqueness),
+      validateTagSemantics: options.validateTagSemantics ?? (options.strict ? true : chunkPD72MVTX_cjs.DEFAULT_OPTIONS.validateTagSemantics),
+      validatePlutusSemantics: options.validatePlutusSemantics ?? (options.strict ? true : chunkPD72MVTX_cjs.DEFAULT_OPTIONS.validatePlutusSemantics),
+      limits: {
+        maxInputSize: options.limits?.maxInputSize ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxInputSize,
+        maxOutputSize: options.limits?.maxOutputSize ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxOutputSize,
+        maxStringLength: options.limits?.maxStringLength ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxStringLength,
+        maxArrayLength: options.limits?.maxArrayLength ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxArrayLength,
+        maxMapSize: options.limits?.maxMapSize ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxMapSize,
+        maxDepth: options.limits?.maxDepth ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxDepth,
+        maxTagDepth: options.limits?.maxTagDepth ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxTagDepth,
+        maxBignumBytes: options.limits?.maxBignumBytes ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxBignumBytes,
+        maxParseTime: options.limits?.maxParseTime ?? chunkPD72MVTX_cjs.DEFAULT_LIMITS.maxParseTime
+      }
+    };
+  };
+  const checkTimeout = (ctx) => {
+    if (!ctx.startTime || !ctx.options?.limits?.maxParseTime) return;
+    const elapsed = Date.now() - ctx.startTime;
+    if (elapsed > ctx.options.limits.maxParseTime) {
+      throw new Error(`Parse timeout: exceeded ${ctx.options.limits.maxParseTime}ms limit (elapsed: ${elapsed}ms)`);
+    }
+  };
+  const { parseInteger } = useCborInteger();
+  const { parseString } = useCborString();
+  const { parseArray, parseMap } = useCborCollection();
+  const { parseTag } = useCborTag();
+  const { parse: parseFloatOrSimple } = useCborFloat();
+  const parse = (hexString, options) => {
+    const cleanHex = hexString.replace(/\s+/g, "");
+    if (!cleanHex || cleanHex.length === 0) {
+      throw new Error("Empty hex string");
+    }
+    if (cleanHex.length % 2 !== 0) {
+      throw new Error("Hex string must have even length");
+    }
+    if (!/^[0-9a-fA-F]+$/.test(cleanHex)) {
+      throw new Error(`Invalid hex character in: ${cleanHex}`);
+    }
+    const mergedOptions = mergeOptions(options);
+    const inputSize = cleanHex.length / 2;
+    if (mergedOptions.limits?.maxInputSize && inputSize > mergedOptions.limits.maxInputSize) {
+      throw new Error(`Input size ${inputSize} bytes exceeds limit of ${mergedOptions.limits.maxInputSize} bytes`);
+    }
+    const buffer = hexToBytes(cleanHex);
+    const initialByte = readByte(buffer, 0);
+    const { majorType } = extractCborHeader(initialByte);
+    switch (majorType) {
+      case 0:
+      // Unsigned integer
+      case 1:
+        return parseInteger(cleanHex, mergedOptions);
+      case 2:
+      // Byte string
+      case 3:
+        return parseString(cleanHex, mergedOptions);
+      case 4:
+        return parseArray(cleanHex, mergedOptions);
+      case 5:
+        return parseMap(cleanHex, mergedOptions);
+      case 6:
+        return parseTag(cleanHex, mergedOptions);
+      case 7:
+        return parseFloatOrSimple(cleanHex, mergedOptions);
+      default:
+        throw new Error(`Unknown major type: ${majorType}`);
+    }
+  };
+  const parseWithSourceMap = (hexString, options) => {
+    const cleanHex = hexString.replace(/\s+/g, "");
+    if (!cleanHex || cleanHex.length === 0) {
+      throw new Error("Empty hex string");
+    }
+    if (cleanHex.length % 2 !== 0) {
+      throw new Error("Hex string must have even length");
+    }
+    if (!/^[0-9a-fA-F]+$/.test(cleanHex)) {
+      throw new Error(`Invalid hex character in: ${cleanHex}`);
+    }
+    const mergedOptions = mergeOptions(options);
+    const inputSize = cleanHex.length / 2;
+    if (mergedOptions.limits?.maxInputSize && inputSize > mergedOptions.limits.maxInputSize) {
+      throw new Error(`Input size ${inputSize} bytes exceeds limit of ${mergedOptions.limits.maxInputSize} bytes`);
+    }
+    const buffer = hexToBytes(cleanHex);
+    const sourceMap = [];
+    const ctx = {
+      buffer,
+      startTime: Date.now(),
+      bytesAllocated: 0,
+      options: mergedOptions
+    };
+    const result = parseValueWithMap(ctx, 0, "", sourceMap);
+    return {
+      value: result.value,
+      bytesRead: result.bytesRead,
+      sourceMap
+    };
+  };
+  const parseValueWithMap = (ctx, offset, path, sourceMap) => {
+    checkTimeout(ctx);
+    const initialByte = readByte(ctx.buffer, offset);
+    const { majorType, additionalInfo } = extractCborHeader(initialByte);
+    const startOffset = offset;
+    let result;
+    let typeDescription;
+    switch (majorType) {
+      case 0:
+        typeDescription = "Unsigned Integer";
+        result = parseIntegerFromBuffer(ctx.buffer, offset, ctx.options);
+        sourceMap.push({
+          path,
+          start: startOffset,
+          end: startOffset + result.bytesRead,
+          majorType,
+          type: typeDescription
+        });
+        break;
+      case 1:
+        typeDescription = "Negative Integer";
+        result = parseIntegerFromBuffer(ctx.buffer, offset, ctx.options);
+        sourceMap.push({
+          path,
+          start: startOffset,
+          end: startOffset + result.bytesRead,
+          majorType,
+          type: typeDescription
+        });
+        break;
+      case 2:
+        {
+          result = parseStringFromBuffer(ctx.buffer, offset, ctx.options);
+          if (ctx.bytesAllocated !== void 0 && result.value instanceof Uint8Array) {
+            ctx.bytesAllocated += result.value.length;
+            if (ctx.options?.limits?.maxOutputSize && ctx.bytesAllocated > ctx.options.limits.maxOutputSize) {
+              throw new Error(`Output size ${ctx.bytesAllocated} bytes exceeds limit of ${ctx.options.limits.maxOutputSize} bytes`);
+            }
+          }
+          const headerBytes = additionalInfo < 24 ? 1 : additionalInfo === 24 ? 2 : additionalInfo === 25 ? 3 : additionalInfo === 26 ? 5 : additionalInfo === 27 ? 9 : 1;
+          const headerEnd = startOffset + headerBytes;
+          const contentLength = result.value instanceof Uint8Array ? result.value.length : 0;
+          typeDescription = `bytes(${contentLength})`;
+          sourceMap.push({
+            path,
+            start: startOffset,
+            end: headerEnd,
+            majorType,
+            type: typeDescription,
+            isHeader: true,
+            headerEnd,
+            contentPath: contentLength > 0 ? `${path}#content` : void 0,
+            children: contentLength > 0 ? [`${path}#content`] : []
+          });
+          if (contentLength > 0) {
+            sourceMap.push({
+              path: `${path}#content`,
+              start: headerEnd,
+              end: startOffset + result.bytesRead,
+              majorType: 2,
+              type: `\u2192 ${contentLength} bytes`,
+              isContent: true,
+              parent: path
+            });
+          }
+        }
+        break;
+      case 3:
+        {
+          result = parseStringFromBuffer(ctx.buffer, offset, ctx.options);
+          if (ctx.bytesAllocated !== void 0 && typeof result.value === "string") {
+            ctx.bytesAllocated += result.value.length;
+            if (ctx.options?.limits?.maxOutputSize && ctx.bytesAllocated > ctx.options.limits.maxOutputSize) {
+              throw new Error(`Output size ${ctx.bytesAllocated} bytes exceeds limit of ${ctx.options.limits.maxOutputSize} bytes`);
+            }
+          }
+          const headerBytes = additionalInfo < 24 ? 1 : additionalInfo === 24 ? 2 : additionalInfo === 25 ? 3 : additionalInfo === 26 ? 5 : additionalInfo === 27 ? 9 : 1;
+          const headerEnd = startOffset + headerBytes;
+          const contentLength = typeof result.value === "string" ? result.value.length : 0;
+          typeDescription = `text(${contentLength})`;
+          sourceMap.push({
+            path,
+            start: startOffset,
+            end: headerEnd,
+            majorType,
+            type: typeDescription,
+            isHeader: true,
+            headerEnd,
+            contentPath: contentLength > 0 ? `${path}#content` : void 0,
+            children: contentLength > 0 ? [`${path}#content`] : []
+          });
+          if (contentLength > 0) {
+            sourceMap.push({
+              path: `${path}#content`,
+              start: headerEnd,
+              end: startOffset + result.bytesRead,
+              majorType: 3,
+              type: `\u2192 "${result.value}"`,
+              isContent: true,
+              parent: path
+            });
+          }
+        }
+        break;
+      case 4:
+        typeDescription = "Array";
+        result = parseArrayWithMap(ctx, offset, path, sourceMap);
+        break;
+      case 5:
+        typeDescription = "Map";
+        result = parseMapWithMap(ctx, offset, path, sourceMap);
+        break;
+      case 6:
+        result = parseTagWithMap(ctx, offset, path, sourceMap);
+        break;
+      case 7:
+        typeDescription = getSimpleTypeDescription(additionalInfo);
+        result = parseFloatFromBuffer(ctx.buffer, offset, ctx.options);
+        sourceMap.push({
+          path,
+          start: startOffset,
+          end: startOffset + result.bytesRead,
+          majorType,
+          type: typeDescription
+        });
+        break;
+      default:
+        throw new Error(`Unknown major type: ${majorType}`);
+    }
+    return result;
+  };
+  const parseIntegerFromBuffer = (buffer, offset, options) => {
+    const hexString = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return parseInteger(hexString, options);
+  };
+  const parseStringFromBuffer = (buffer, offset, options) => {
+    const hexString = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return parseString(hexString, options);
+  };
+  const parseFloatFromBuffer = (buffer, offset, options) => {
+    const hexString = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return parseFloatOrSimple(hexString, options);
+  };
+  const parseArrayWithMap = (ctx, offset, path, sourceMap) => {
+    const startOffset = offset;
+    const initialByte = readByte(ctx.buffer, offset);
+    const { additionalInfo } = extractCborHeader(initialByte);
+    let currentOffset = offset + 1;
+    const items = [];
+    let length;
+    let isIndefinite = false;
+    if (additionalInfo < 24) {
+      length = additionalInfo;
+    } else if (additionalInfo === 24) {
+      length = readByte(ctx.buffer, currentOffset);
+      currentOffset += 1;
+    } else if (additionalInfo === 25) {
+      length = readUint(ctx.buffer, currentOffset, 2);
+      currentOffset += 2;
+    } else if (additionalInfo === 26) {
+      length = readUint(ctx.buffer, currentOffset, 4);
+      currentOffset += 4;
+    } else if (additionalInfo === 27) {
+      const bigLength = readBigUint(ctx.buffer, currentOffset, 8);
+      if (bigLength > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error("Array length exceeds maximum safe integer");
+      }
+      length = Number(bigLength);
+      currentOffset += 8;
+    } else if (additionalInfo === 31) {
+      isIndefinite = true;
+      length = 0;
+    } else {
+      throw new Error(`Invalid additional info: ${additionalInfo}`);
+    }
+    const headerEnd = currentOffset;
+    const arrayEntryIndex = sourceMap.length;
+    sourceMap.push({
+      path,
+      start: startOffset,
+      end: headerEnd,
+      majorType: 4,
+      type: isIndefinite ? "array(indefinite)" : `array(${length})`,
+      isHeader: true,
+      headerEnd
+    });
+    const childPaths = [];
+    if (isIndefinite) {
+      let index = 0;
+      while (currentOffset < ctx.buffer.length) {
+        const nextByte = readByte(ctx.buffer, currentOffset);
+        if (nextByte === 255) {
+          currentOffset++;
+          break;
+        }
+        const elementPath = `${path}[${index}]`;
+        childPaths.push(elementPath);
+        const elementResult = parseValueWithMap(ctx, currentOffset, elementPath, sourceMap);
+        items.push(elementResult.value);
+        currentOffset += elementResult.bytesRead;
+        const elementEntry = sourceMap.find((e) => e.path === elementPath);
+        if (elementEntry) {
+          elementEntry.parent = path;
+        }
+        index++;
+      }
+    } else {
+      for (let i = 0; i < length; i++) {
+        const elementPath = `${path}[${i}]`;
+        childPaths.push(elementPath);
+        const elementResult = parseValueWithMap(ctx, currentOffset, elementPath, sourceMap);
+        items.push(elementResult.value);
+        currentOffset += elementResult.bytesRead;
+        const elementEntry = sourceMap.find((e) => e.path === elementPath);
+        if (elementEntry) {
+          elementEntry.parent = path;
+        }
+      }
+    }
+    const bytesRead = currentOffset - offset;
+    if (childPaths.length > 0 && sourceMap[arrayEntryIndex]) {
+      sourceMap[arrayEntryIndex].children = childPaths;
+    }
+    return {
+      value: items,
+      bytesRead
+    };
+  };
+  const parseMapWithMap = (ctx, offset, path, sourceMap) => {
+    const startOffset = offset;
+    const initialByte = readByte(ctx.buffer, offset);
+    const { additionalInfo } = extractCborHeader(initialByte);
+    let currentOffset = offset + 1;
+    const map = /* @__PURE__ */ new Map();
+    let length;
+    let isIndefinite = false;
+    if (additionalInfo < 24) {
+      length = additionalInfo;
+    } else if (additionalInfo === 24) {
+      length = readByte(ctx.buffer, currentOffset);
+      currentOffset += 1;
+    } else if (additionalInfo === 25) {
+      length = readUint(ctx.buffer, currentOffset, 2);
+      currentOffset += 2;
+    } else if (additionalInfo === 26) {
+      length = readUint(ctx.buffer, currentOffset, 4);
+      currentOffset += 4;
+    } else if (additionalInfo === 27) {
+      const bigLength = readBigUint(ctx.buffer, currentOffset, 8);
+      if (bigLength > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error("Map length exceeds maximum safe integer");
+      }
+      length = Number(bigLength);
+      currentOffset += 8;
+    } else if (additionalInfo === 31) {
+      isIndefinite = true;
+      length = 0;
+    } else {
+      throw new Error(`Invalid additional info: ${additionalInfo}`);
+    }
+    const headerEnd = currentOffset;
+    const mapEntryIndex = sourceMap.length;
+    sourceMap.push({
+      path,
+      start: startOffset,
+      end: headerEnd,
+      majorType: 5,
+      type: isIndefinite ? "map(indefinite)" : `map(${length})`,
+      isHeader: true,
+      headerEnd
+    });
+    const childPaths = [];
+    const seenKeys = /* @__PURE__ */ new Set();
+    if (isIndefinite) {
+      while (currentOffset < ctx.buffer.length) {
+        const nextByte = readByte(ctx.buffer, currentOffset);
+        if (nextByte === 255) {
+          currentOffset++;
+          break;
+        }
+        const keyPath = `${path}${path ? "." : ""}#key`;
+        const keyResult = parseValueWithMap(ctx, currentOffset, keyPath, sourceMap);
+        currentOffset += keyResult.bytesRead;
+        const keyString = keyResult.value instanceof Uint8Array ? Array.from(keyResult.value).map((b) => b.toString(16).padStart(2, "0")).join("") : String(keyResult.value);
+        if (seenKeys.has(keyString)) {
+          const mode = ctx.options?.dupMapKeyMode || "allow";
+          if (mode === "reject") {
+            throw new Error(`Duplicate map key detected: ${keyString} at offset ${currentOffset}`);
+          } else if (mode === "warn") {
+            logger.warn(`Duplicate map key detected: ${keyString} at offset ${currentOffset}`);
+          }
+        }
+        seenKeys.add(keyString);
+        const valuePath = path ? `${path}.${keyString}` : `.${keyString}`;
+        childPaths.push(valuePath);
+        const valueResult = parseValueWithMap(ctx, currentOffset, valuePath, sourceMap);
+        map.set(keyResult.value, valueResult.value);
+        currentOffset += valueResult.bytesRead;
+        const valueEntry = sourceMap.find((e) => e.path === valuePath);
+        if (valueEntry) {
+          valueEntry.parent = path;
+        }
+      }
+    } else {
+      for (let i = 0; i < length; i++) {
+        const keyPath = `${path}${path ? "." : ""}#key${i}`;
+        const keyResult = parseValueWithMap(ctx, currentOffset, keyPath, sourceMap);
+        currentOffset += keyResult.bytesRead;
+        const keyString = keyResult.value instanceof Uint8Array ? Array.from(keyResult.value).map((b) => b.toString(16).padStart(2, "0")).join("") : String(keyResult.value);
+        if (seenKeys.has(keyString)) {
+          const mode = ctx.options?.dupMapKeyMode || "allow";
+          if (mode === "reject") {
+            throw new Error(`Duplicate map key detected: ${keyString} at offset ${currentOffset}`);
+          } else if (mode === "warn") {
+            logger.warn(`Duplicate map key detected: ${keyString} at offset ${currentOffset}`);
+          }
+        }
+        seenKeys.add(keyString);
+        const valuePath = path ? `${path}.${keyString}` : `.${keyString}`;
+        childPaths.push(valuePath);
+        const valueResult = parseValueWithMap(ctx, currentOffset, valuePath, sourceMap);
+        map.set(keyResult.value, valueResult.value);
+        currentOffset += valueResult.bytesRead;
+        const valueEntry = sourceMap.find((e) => e.path === valuePath);
+        if (valueEntry) {
+          valueEntry.parent = path;
+        }
+      }
+    }
+    const bytesRead = currentOffset - offset;
+    if (sourceMap[mapEntryIndex]) {
+      sourceMap[mapEntryIndex].children = childPaths;
+    }
+    return {
+      value: map,
+      bytesRead
+    };
+  };
+  const parseTagNumberHelper = (buffer, offset, ai) => {
+    if (ai < 24) {
+      return { tagNumber: ai, bytesConsumed: 0 };
+    } else if (ai === 24) {
+      const tagNumber = readByte(buffer, offset);
+      return { tagNumber, bytesConsumed: 1 };
+    } else if (ai === 25) {
+      const tagNumber = readUint(buffer, offset, 2);
+      return { tagNumber, bytesConsumed: 2 };
+    } else if (ai === 26) {
+      const tagNumber = readUint(buffer, offset, 4);
+      return { tagNumber, bytesConsumed: 4 };
+    } else if (ai === 27) {
+      const tagBigInt = readBigUint(buffer, offset, 8);
+      if (tagBigInt <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        return { tagNumber: Number(tagBigInt), bytesConsumed: 8 };
+      } else {
+        throw new Error(`Tag number ${tagBigInt} exceeds maximum safe integer`);
+      }
+    } else if (ai >= 28 && ai <= 30) {
+      throw new Error(`Reserved additional info ${ai} for major type 6`);
+    } else {
+      throw new Error(`Invalid additional info ${ai} for tags`);
+    }
+  };
+  const parseTagWithMap = (ctx, offset, path, sourceMap) => {
+    const startOffset = offset;
+    const initialByte = readByte(ctx.buffer, offset);
+    const { additionalInfo } = extractCborHeader(initialByte);
+    const { tagNumber, bytesConsumed } = parseTagNumberHelper(
+      ctx.buffer,
+      offset + 1,
+      additionalInfo
+    );
+    let currentOffset = offset + 1 + bytesConsumed;
+    const headerEnd = currentOffset;
+    const tagEntryIndex = sourceMap.length;
+    sourceMap.push({
+      path,
+      start: startOffset,
+      end: headerEnd,
+      majorType: 6,
+      type: `tag(${tagNumber})`,
+      isHeader: true,
+      headerEnd,
+      children: []
+    });
+    const valuePath = `${path}.value`;
+    const valueResult = parseValueWithMap(ctx, currentOffset, valuePath, sourceMap);
+    currentOffset += valueResult.bytesRead;
+    if (sourceMap[tagEntryIndex]) {
+      sourceMap[tagEntryIndex].children = [valuePath];
+    }
+    const valueEntry = sourceMap.find((e) => e.path === valuePath);
+    if (valueEntry) {
+      valueEntry.parent = path;
+    }
+    const hexString = Array.from(ctx.buffer.slice(startOffset, currentOffset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const tagResult = parseTag(hexString, ctx.options);
+    return {
+      value: tagResult.value,
+      bytesRead: currentOffset - startOffset
+    };
+  };
+  const getSimpleTypeDescription = (ai) => {
+    if (ai === 20) return "Simple: false";
+    if (ai === 21) return "Simple: true";
+    if (ai === 22) return "Simple: null";
+    if (ai === 23) return "Simple: undefined";
+    if (ai === 25) return "Float16";
+    if (ai === 26) return "Float32";
+    if (ai === 27) return "Float64";
+    if (ai < 20) return `Simple Value ${ai}`;
+    return "Simple Value";
+  };
+  const parseSequence = (hexString, options) => {
+    const cleanHex = hexString.replace(/\s+/g, "");
+    if (!cleanHex || cleanHex.length === 0) {
+      return [];
+    }
+    if (cleanHex.length % 2 !== 0) {
+      throw new Error("Hex string must have even length");
+    }
+    if (!/^[0-9a-fA-F]+$/.test(cleanHex)) {
+      throw new Error(`Invalid hex character in: ${cleanHex}`);
+    }
+    const mergedOptions = mergeOptions(options);
+    const buffer = hexToBytes(cleanHex);
+    const results = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+      const byte = readByte(buffer, offset);
+      if (byte === 255) {
+        throw new Error(`Unexpected break code (0xff) at offset ${offset} - not inside indefinite-length item`);
+      }
+      const remainingHex = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+      const result = parse(remainingHex, mergedOptions);
+      results.push(result.value);
+      offset += result.bytesRead;
+    }
+    return results;
+  };
+  const parseSequenceWithSourceMap = (hexString, options) => {
+    const cleanHex = hexString.replace(/\s+/g, "");
+    if (!cleanHex || cleanHex.length === 0) {
+      return { values: [], sourceMaps: [] };
+    }
+    if (cleanHex.length % 2 !== 0) {
+      throw new Error("Hex string must have even length");
+    }
+    if (!/^[0-9a-fA-F]+$/.test(cleanHex)) {
+      throw new Error(`Invalid hex character in: ${cleanHex}`);
+    }
+    const mergedOptions = mergeOptions(options);
+    const buffer = hexToBytes(cleanHex);
+    const values = [];
+    const sourceMaps = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+      const byte = readByte(buffer, offset);
+      if (byte === 255) {
+        throw new Error(`Unexpected break code (0xff) at offset ${offset}`);
+      }
+      const remainingHex = Array.from(buffer.slice(offset)).map((b) => b.toString(16).padStart(2, "0")).join("");
+      const result = parseWithSourceMap(remainingHex, mergedOptions);
+      const adjustedSourceMap = result.sourceMap.map((entry) => ({
+        ...entry,
+        start: entry.start + offset,
+        end: entry.end + offset
+      }));
+      values.push(result.value);
+      sourceMaps.push(adjustedSourceMap);
+      offset += result.bytesRead;
+    }
+    return { values, sourceMaps };
+  };
+  return {
+    parse,
+    parseWithSourceMap,
+    parseSequence,
+    parseSequenceWithSourceMap
+  };
+}
+
+exports.bytesToHex = bytesToHex;
+exports.extractCborHeader = extractCborHeader;
+exports.hexToBytes = hexToBytes;
+exports.readBigUint = readBigUint;
+exports.readByte = readByte;
+exports.readUint = readUint;
+exports.useCborCollection = useCborCollection;
+exports.useCborFloat = useCborFloat;
+exports.useCborInteger = useCborInteger;
+exports.useCborParser = useCborParser;
+exports.useCborString = useCborString;
+exports.useCborTag = useCborTag;
+exports.validateUtf8Strict = validateUtf8Strict;
+//# sourceMappingURL=chunk-2HBCILJS.cjs.map
+//# sourceMappingURL=chunk-2HBCILJS.cjs.map