@marcuspuchalla/nachos 0.1.0

package/dist/chunk-2FUTHZQQ.cjs

@@ -0,0 +1,755 @@
+'use strict';
+
+var chunkPD72MVTX_cjs = require('./chunk-PD72MVTX.cjs');
+
+// src/encoder/types.ts
+var DEFAULT_ENCODE_OPTIONS = {
+  canonical: false,
+  allowIndefinite: true,
+  rejectDuplicateKeys: false,
+  maxDepth: 64,
+  maxOutputSize: 100 * 1024 * 1024
+  // 100 MB
+};
+
+// src/encoder/utils.ts
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function concatenateUint8Arrays(arrays) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function compareBytes(a, b) {
+  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 writeUint(value, bytes) {
+  const result = new Uint8Array(bytes);
+  for (let i = bytes - 1; i >= 0; i--) {
+    result[i] = value & 255;
+    value = value >>> 8;
+  }
+  return result;
+}
+function writeBigUint(value, bytes) {
+  const result = new Uint8Array(bytes);
+  for (let i = bytes - 1; i >= 0; i--) {
+    result[i] = Number(value & 0xffn);
+    value = value >> 8n;
+  }
+  return result;
+}
+
+// src/encoder/composables/useCborIntegerEncoder.ts
+function useCborIntegerEncoder() {
+  const encodeUnsignedInt = (value) => {
+    const bigValue = typeof value === "bigint" ? value : BigInt(value);
+    if (bigValue < 0n) {
+      throw new Error("Cannot encode negative value as unsigned integer");
+    }
+    const MAX_UINT64 = 18446744073709551615n;
+    if (bigValue > MAX_UINT64) {
+      throw new Error("Value exceeds maximum unsigned integer (2^64-1)");
+    }
+    let bytes;
+    if (bigValue <= 23n) {
+      bytes = new Uint8Array([Number(bigValue)]);
+    } else if (bigValue <= 255n) {
+      bytes = new Uint8Array([24, Number(bigValue)]);
+    } else if (bigValue <= 65535n) {
+      const valueBytes = writeUint(Number(bigValue), 2);
+      bytes = new Uint8Array([25, ...valueBytes]);
+    } else if (bigValue <= 4294967295n) {
+      const valueBytes = writeUint(Number(bigValue), 4);
+      bytes = new Uint8Array([26, ...valueBytes]);
+    } else {
+      const valueBytes = writeBigUint(bigValue, 8);
+      bytes = new Uint8Array([27, ...valueBytes]);
+    }
+    return {
+      bytes,
+      hex: bytesToHex(bytes)
+    };
+  };
+  const encodeNegativeInt = (value) => {
+    const bigValue = typeof value === "bigint" ? value : BigInt(value);
+    if (bigValue >= 0n) {
+      throw new Error("Cannot encode positive value as negative integer");
+    }
+    const MIN_INT64 = -18446744073709551616n;
+    if (bigValue < MIN_INT64) {
+      throw new Error("Value exceeds minimum negative integer (-2^64)");
+    }
+    const encoded = -1n - bigValue;
+    let bytes;
+    if (encoded <= 23n) {
+      bytes = new Uint8Array([32 + Number(encoded)]);
+    } else if (encoded <= 255n) {
+      bytes = new Uint8Array([56, Number(encoded)]);
+    } else if (encoded <= 65535n) {
+      const valueBytes = writeUint(Number(encoded), 2);
+      bytes = new Uint8Array([57, ...valueBytes]);
+    } else if (encoded <= 4294967295n) {
+      const valueBytes = writeUint(Number(encoded), 4);
+      bytes = new Uint8Array([58, ...valueBytes]);
+    } else {
+      const valueBytes = writeBigUint(encoded, 8);
+      bytes = new Uint8Array([59, ...valueBytes]);
+    }
+    return {
+      bytes,
+      hex: bytesToHex(bytes)
+    };
+  };
+  const encodeInteger = (value) => {
+    const bigValue = typeof value === "bigint" ? value : BigInt(value);
+    if (bigValue < 0n) {
+      return encodeNegativeInt(bigValue);
+    } else {
+      return encodeUnsignedInt(bigValue);
+    }
+  };
+  return {
+    encodeUnsignedInt,
+    encodeNegativeInt,
+    encodeInteger
+  };
+}
+
+// src/encoder/composables/useCborStringEncoder.ts
+function useCborStringEncoder(globalOptions) {
+  const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions };
+  const { isCborByteString } = chunkPD72MVTX_cjs.useCborByteString();
+  const { isCborTextString } = chunkPD72MVTX_cjs.useCborTextString();
+  const encodeLengthHeader = (majorType, length) => {
+    const baseValue = majorType << 5;
+    if (length <= 23) {
+      return new Uint8Array([baseValue | length]);
+    } else if (length <= 255) {
+      return new Uint8Array([baseValue | 24, length]);
+    } else if (length <= 65535) {
+      const lengthBytes = writeUint(length, 2);
+      return new Uint8Array([baseValue | 25, ...lengthBytes]);
+    } else if (length <= 4294967295) {
+      const lengthBytes = writeUint(length, 4);
+      return new Uint8Array([baseValue | 26, ...lengthBytes]);
+    } else {
+      const lengthBytes = length > Number.MAX_SAFE_INTEGER ? writeBigUint(BigInt(length), 8) : writeUint(length, 8);
+      return new Uint8Array([baseValue | 27, ...lengthBytes]);
+    }
+  };
+  const encodeByteString = (data, encodeOptions) => {
+    const isIndefinite = isCborByteString(data) && data[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+    if (encodeOptions?.indefinite || Array.isArray(data) || isIndefinite) {
+      if (options.canonical) {
+        throw new Error("Indefinite-length encoding not allowed in canonical mode");
+      }
+      if (isCborByteString(data) && data.chunks) {
+        return encodeByteStringIndefinite(data.chunks);
+      }
+      const bytes2 = isCborByteString(data) ? data.bytes : Array.isArray(data) ? data : [data];
+      return encodeByteStringIndefinite(Array.isArray(bytes2) ? bytes2 : [bytes2]);
+    }
+    const bytes = isCborByteString(data) ? data.bytes : data;
+    const header = encodeLengthHeader(2, bytes.length);
+    const result = concatenateUint8Arrays([header, bytes]);
+    if (result.length > options.maxOutputSize) {
+      throw new Error("Encoded output exceeds maximum size");
+    }
+    return {
+      bytes: result,
+      hex: bytesToHex(result)
+    };
+  };
+  const encodeByteStringIndefinite = (chunks) => {
+    if (options.canonical) {
+      throw new Error("Indefinite-length encoding not allowed in canonical mode");
+    }
+    const parts = [new Uint8Array([95])];
+    for (const chunk of chunks) {
+      const header = encodeLengthHeader(2, chunk.length);
+      parts.push(header);
+      parts.push(chunk);
+    }
+    parts.push(new Uint8Array([255]));
+    const result = concatenateUint8Arrays(parts);
+    return {
+      bytes: result,
+      hex: bytesToHex(result)
+    };
+  };
+  const encodeTextString = (text, encodeOptions) => {
+    const isIndefinite = isCborTextString(text) && text[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+    if (encodeOptions?.indefinite || isIndefinite) {
+      if (options.canonical) {
+        throw new Error("Indefinite-length encoding not allowed in canonical mode");
+      }
+      if (isCborTextString(text) && text.chunks) {
+        return encodeTextStringIndefinite(text.chunks);
+      }
+      const textStr2 = isCborTextString(text) ? text.text : text;
+      return encodeTextStringIndefinite([textStr2]);
+    }
+    const textStr = isCborTextString(text) ? text.text : text;
+    const encoder = new TextEncoder();
+    const utf8Bytes = encoder.encode(textStr);
+    const header = encodeLengthHeader(3, utf8Bytes.length);
+    const result = concatenateUint8Arrays([header, utf8Bytes]);
+    if (result.length > options.maxOutputSize) {
+      throw new Error("Encoded output exceeds maximum size");
+    }
+    return {
+      bytes: result,
+      hex: bytesToHex(result)
+    };
+  };
+  const encodeTextStringIndefinite = (chunks) => {
+    if (options.canonical) {
+      throw new Error("Indefinite-length encoding not allowed in canonical mode");
+    }
+    const parts = [new Uint8Array([127])];
+    const encoder = new TextEncoder();
+    for (const chunk of chunks) {
+      const utf8Bytes = encoder.encode(chunk);
+      const header = encodeLengthHeader(3, utf8Bytes.length);
+      parts.push(header);
+      parts.push(utf8Bytes);
+    }
+    parts.push(new Uint8Array([255]));
+    const result = concatenateUint8Arrays(parts);
+    return {
+      bytes: result,
+      hex: bytesToHex(result)
+    };
+  };
+  return {
+    encodeByteString,
+    encodeByteStringIndefinite,
+    encodeTextString,
+    encodeTextStringIndefinite
+  };
+}
+
+// src/encoder/composables/useCborCollectionEncoder.ts
+function useCborCollectionEncoder(globalOptions) {
+  const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions };
+  const { encodeInteger } = useCborIntegerEncoder();
+  const { encodeTextString, encodeByteString } = useCborStringEncoder(globalOptions);
+  const { isCborByteString } = chunkPD72MVTX_cjs.useCborByteString();
+  const { isCborTextString } = chunkPD72MVTX_cjs.useCborTextString();
+  let mainEncode = null;
+  const setMainEncode = (encodeFn) => {
+    mainEncode = encodeFn;
+  };
+  const encodeValue = (value, ctx) => {
+    if (ctx.depth > ctx.options.maxDepth) {
+      throw new Error("Maximum nesting depth exceeded");
+    }
+    if (value === null || value === void 0) {
+      return new Uint8Array([246]);
+    } else if (typeof value === "boolean") {
+      return new Uint8Array([value ? 245 : 244]);
+    } else if (typeof value === "number" || typeof value === "bigint") {
+      return encodeInteger(value).bytes;
+    } else if (typeof value === "string" || isCborTextString(value)) {
+      return encodeTextString(value).bytes;
+    } else if (value instanceof Uint8Array || isCborByteString(value)) {
+      return encodeByteString(value).bytes;
+    } else if (Array.isArray(value)) {
+      const isIndefinite = value[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+      const newCtx = { ...ctx, depth: ctx.depth + 1 };
+      if (isIndefinite) {
+        const parts = [new Uint8Array([159])];
+        for (const item of value) {
+          const encoded = encodeValue(item, newCtx);
+          parts.push(encoded);
+        }
+        parts.push(new Uint8Array([255]));
+        return concatenateUint8Arrays(parts);
+      } else {
+        return encodeArrayInternal(value, newCtx).bytes;
+      }
+    } else if (typeof value === "object" && value !== null && "tag" in value && "value" in value) {
+      if (mainEncode) {
+        return mainEncode(value).bytes;
+      }
+      throw new Error("Tagged value encoding requires main encoder to be set");
+    } else if (value instanceof Map || typeof value === "object" && value !== null) {
+      const isIndefinite = value[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+      const newCtx = { ...ctx, depth: ctx.depth + 1 };
+      if (isIndefinite) {
+        const entries = value instanceof Map ? Array.from(value.entries()) : Object.entries(value);
+        const parts = [new Uint8Array([191])];
+        for (const [key, val] of entries) {
+          const encodedKey = encodeValue(key, newCtx);
+          const encodedValue = encodeValue(val, newCtx);
+          parts.push(encodedKey);
+          parts.push(encodedValue);
+        }
+        parts.push(new Uint8Array([255]));
+        return concatenateUint8Arrays(parts);
+      } else {
+        return encodeMapInternal(value, newCtx).bytes;
+      }
+    } else {
+      throw new Error(`Unsupported value type: ${typeof value}`);
+    }
+  };
+  const encodeLengthHeader = (majorType, length) => {
+    const baseValue = majorType << 5;
+    if (length <= 23) {
+      return new Uint8Array([baseValue | length]);
+    } else if (length <= 255) {
+      return new Uint8Array([baseValue | 24, length]);
+    } else if (length <= 65535) {
+      return new Uint8Array([baseValue | 25, length >> 8, length & 255]);
+    } else if (length <= 4294967295) {
+      return new Uint8Array([
+        baseValue | 26,
+        length >> 24 & 255,
+        length >> 16 & 255,
+        length >> 8 & 255,
+        length & 255
+      ]);
+    } else {
+      throw new Error("Collection too large to encode");
+    }
+  };
+  const encodeArrayInternal = (array, ctx) => {
+    const header = encodeLengthHeader(4, array.length);
+    const parts = [header];
+    for (const item of array) {
+      const encoded = encodeValue(item, ctx);
+      parts.push(encoded);
+    }
+    const result = concatenateUint8Arrays(parts);
+    ctx.bytesWritten += result.length;
+    if (ctx.bytesWritten > ctx.options.maxOutputSize) {
+      throw new Error("Encoded output exceeds maximum size");
+    }
+    return {
+      bytes: result,
+      hex: bytesToHex(result)
+    };
+  };
+  const encodeArray = (array, encodeOptions) => {
+    const isIndefinite = array[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+    if (encodeOptions?.indefinite || isIndefinite) {
+      if (options.canonical) {
+        throw new Error("Indefinite-length encoding not allowed in canonical mode");
+      }
+      return encodeArrayIndefinite(array);
+    }
+    const ctx = {
+      depth: 0,
+      bytesWritten: 0,
+      options
+    };
+    return encodeArrayInternal(array, ctx);
+  };
+  const encodeArrayIndefinite = (array) => {
+    if (options.canonical) {
+      throw new Error("Indefinite-length encoding not allowed in canonical mode");
+    }
+    const parts = [new Uint8Array([159])];
+    const ctx = {
+      depth: 0,
+      bytesWritten: 0,
+      options
+    };
+    for (const item of array) {
+      const encoded = encodeValue(item, ctx);
+      parts.push(encoded);
+    }
+    parts.push(new Uint8Array([255]));
+    const result = concatenateUint8Arrays(parts);
+    return {
+      bytes: result,
+      hex: bytesToHex(result)
+    };
+  };
+  const encodeMapInternal = (map, ctx) => {
+    let entries;
+    if (map[chunkPD72MVTX_cjs.ALL_ENTRIES_SYMBOL]) {
+      entries = map[chunkPD72MVTX_cjs.ALL_ENTRIES_SYMBOL];
+    } else {
+      entries = map instanceof Map ? Array.from(map.entries()) : Object.entries(map);
+    }
+    if (ctx.options.canonical && !map[chunkPD72MVTX_cjs.ALL_ENTRIES_SYMBOL]) {
+      entries.sort((a, b) => {
+        const keyA = encodeValue(a[0], { ...ctx, depth: ctx.depth + 1 });
+        const keyB = encodeValue(b[0], { ...ctx, depth: ctx.depth + 1 });
+        return compareBytes(keyA, keyB);
+      });
+    }
+    const header = encodeLengthHeader(5, entries.length);
+    const parts = [header];
+    for (const [key, value] of entries) {
+      const encodedKey = encodeValue(key, ctx);
+      const encodedValue = encodeValue(value, ctx);
+      parts.push(encodedKey);
+      parts.push(encodedValue);
+    }
+    const result = concatenateUint8Arrays(parts);
+    ctx.bytesWritten += result.length;
+    if (ctx.bytesWritten > ctx.options.maxOutputSize) {
+      throw new Error("Encoded output exceeds maximum size");
+    }
+    return {
+      bytes: result,
+      hex: bytesToHex(result)
+    };
+  };
+  const encodeMap = (map, encodeOptions) => {
+    const isIndefinite = map[chunkPD72MVTX_cjs.INDEFINITE_SYMBOL] === true;
+    if (encodeOptions?.indefinite || isIndefinite) {
+      if (options.canonical) {
+        throw new Error("Indefinite-length encoding not allowed in canonical mode");
+      }
+      return encodeMapIndefinite(map);
+    }
+    const ctx = {
+      depth: 0,
+      bytesWritten: 0,
+      options
+    };
+    return encodeMapInternal(map, ctx);
+  };
+  const encodeMapIndefinite = (map) => {
+    if (options.canonical) {
+      throw new Error("Indefinite-length encoding not allowed in canonical mode");
+    }
+    const entries = map instanceof Map ? Array.from(map.entries()) : Object.entries(map);
+    const parts = [new Uint8Array([191])];
+    const ctx = {
+      depth: 0,
+      bytesWritten: 0,
+      options
+    };
+    for (const [key, value] of entries) {
+      const encodedKey = encodeValue(key, ctx);
+      const encodedValue = encodeValue(value, ctx);
+      parts.push(encodedKey);
+      parts.push(encodedValue);
+    }
+    parts.push(new Uint8Array([255]));
+    const result = concatenateUint8Arrays(parts);
+    return {
+      bytes: result,
+      hex: bytesToHex(result)
+    };
+  };
+  return {
+    encodeArray,
+    encodeArrayIndefinite,
+    encodeMap,
+    encodeMapIndefinite,
+    setMainEncode
+  };
+}
+
+// src/encoder/composables/useCborSimpleEncoder.ts
+function useCborSimpleEncoder(_globalOptions) {
+  const { encodeInteger } = useCborIntegerEncoder();
+  const encodeSimple = (value) => {
+    let byte;
+    if (value === false) {
+      byte = 244;
+    } else if (value === true) {
+      byte = 245;
+    } else if (value === null) {
+      byte = 246;
+    } else if (value === void 0) {
+      byte = 247;
+    } else {
+      throw new Error(`Unsupported simple value: ${value}`);
+    }
+    return {
+      bytes: new Uint8Array([byte]),
+      hex: bytesToHex(new Uint8Array([byte]))
+    };
+  };
+  const encodeFloat16Bytes = (value) => {
+    if (value === 0) return new Uint8Array([0, 0]);
+    if (value === -0) return new Uint8Array([128, 0]);
+    if (Number.isNaN(value)) return new Uint8Array([126, 0]);
+    if (value === Infinity) return new Uint8Array([124, 0]);
+    if (value === -Infinity) return new Uint8Array([252, 0]);
+    const sign = value < 0 ? 1 : 0;
+    const absValue = Math.abs(value);
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setFloat64(0, absValue, false);
+    const bits = view.getBigUint64(0, false);
+    const exp64 = Number(bits >> 52n & 0x7ffn) - 1023;
+    const mant64 = Number(bits & 0xfffffffffffffn);
+    let exp16;
+    let mant16;
+    if (exp64 < -14) {
+      exp16 = 0;
+      mant16 = 0;
+    } else if (exp64 > 15) {
+      exp16 = 31;
+      mant16 = 0;
+    } else {
+      exp16 = exp64 + 15;
+      mant16 = mant64 >> 42;
+    }
+    const float16 = sign << 15 | exp16 << 10 | mant16;
+    return new Uint8Array([
+      float16 >> 8 & 255,
+      float16 & 255
+    ]);
+  };
+  const encodeFloat32Bytes = (value) => {
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    view.setFloat32(0, value, false);
+    return new Uint8Array(buffer);
+  };
+  const encodeFloat64Bytes = (value) => {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setFloat64(0, value, false);
+    return new Uint8Array(buffer);
+  };
+  const canBeFloat16 = (value) => {
+    if (!Number.isFinite(value) || value === 0 || value === -0) {
+      return true;
+    }
+    const absValue = Math.abs(value);
+    if (absValue < 6103515625e-14 || absValue > 65504) {
+      return false;
+    }
+    const bytes = encodeFloat16Bytes(value);
+    const view = new DataView(bytes.buffer);
+    const bits = view.getUint16(0, false);
+    const sign = bits >> 15 & 1;
+    const exp = bits >> 10 & 31;
+    const mant = bits & 1023;
+    let decoded;
+    if (exp === 0) {
+      decoded = (sign ? -1 : 1) * Math.pow(2, -14) * (mant / 1024);
+    } else if (exp === 31) {
+      decoded = mant === 0 ? sign ? -Infinity : Infinity : NaN;
+    } else {
+      decoded = (sign ? -1 : 1) * Math.pow(2, exp - 15) * (1 + mant / 1024);
+    }
+    return decoded === value;
+  };
+  const canBeFloat32 = (value) => {
+    if (!Number.isFinite(value) || value === 0 || value === -0) {
+      return true;
+    }
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    view.setFloat32(0, value, false);
+    const decoded = view.getFloat32(0, false);
+    return decoded === value;
+  };
+  const isInteger = (value) => {
+    return Number.isInteger(value) && Number.isSafeInteger(value);
+  };
+  const encodeFloat = (value, precision) => {
+    let bytes;
+    if (isInteger(value) && !precision) {
+      return encodeInteger(value);
+    }
+    if (precision === 16) {
+      const floatBytes = encodeFloat16Bytes(value);
+      bytes = new Uint8Array([249, ...floatBytes]);
+    } else if (precision === 32) {
+      const floatBytes = encodeFloat32Bytes(value);
+      bytes = new Uint8Array([250, ...floatBytes]);
+    } else if (precision === 64) {
+      const floatBytes = encodeFloat64Bytes(value);
+      bytes = new Uint8Array([251, ...floatBytes]);
+    } else {
+      if (canBeFloat16(value)) {
+        const floatBytes = encodeFloat16Bytes(value);
+        bytes = new Uint8Array([249, ...floatBytes]);
+      } else if (canBeFloat32(value)) {
+        const floatBytes = encodeFloat32Bytes(value);
+        bytes = new Uint8Array([250, ...floatBytes]);
+      } else {
+        const floatBytes = encodeFloat64Bytes(value);
+        bytes = new Uint8Array([251, ...floatBytes]);
+      }
+    }
+    return {
+      bytes,
+      hex: bytesToHex(bytes)
+    };
+  };
+  return {
+    encodeSimple,
+    encodeFloat
+  };
+}
+
+// src/encoder/composables/useCborTagEncoder.ts
+function useCborTagEncoder() {
+  const encodeTagNumber = (tagNumber) => {
+    const bigTag = typeof tagNumber === "bigint" ? tagNumber : BigInt(tagNumber);
+    if (bigTag < 0n) {
+      throw new Error("Tag number cannot be negative");
+    }
+    const MAX_UINT64 = 18446744073709551615n;
+    if (bigTag > MAX_UINT64) {
+      throw new Error("Tag number exceeds maximum (2^64-1)");
+    }
+    let bytes;
+    if (bigTag <= 23n) {
+      bytes = new Uint8Array([192 + Number(bigTag)]);
+    } else if (bigTag <= 255n) {
+      bytes = new Uint8Array([216, Number(bigTag)]);
+    } else if (bigTag <= 65535n) {
+      const valueBytes = writeUint(Number(bigTag), 2);
+      bytes = new Uint8Array([217, ...valueBytes]);
+    } else if (bigTag <= 4294967295n) {
+      const valueBytes = writeUint(Number(bigTag), 4);
+      bytes = new Uint8Array([218, ...valueBytes]);
+    } else {
+      const valueBytes = writeBigUint(bigTag, 8);
+      bytes = new Uint8Array([219, ...valueBytes]);
+    }
+    return bytes;
+  };
+  const encodeTag = (tagNumber, value, encode) => {
+    const tagBytes = encodeTagNumber(tagNumber);
+    const valueResult = encode(value);
+    const totalLength = tagBytes.length + valueResult.bytes.length;
+    const bytes = new Uint8Array(totalLength);
+    bytes.set(tagBytes, 0);
+    bytes.set(valueResult.bytes, tagBytes.length);
+    return {
+      bytes,
+      hex: bytesToHex(bytes)
+    };
+  };
+  const encodeTaggedValue = (taggedValue, encode) => {
+    return encodeTag(taggedValue.tag, taggedValue.value, encode);
+  };
+  return {
+    encodeTagNumber,
+    encodeTag,
+    encodeTaggedValue
+  };
+}
+
+// src/encoder/composables/useCborEncoder.ts
+function useCborEncoder(globalOptions) {
+  const options = { ...DEFAULT_ENCODE_OPTIONS, ...globalOptions };
+  const { encodeInteger } = useCborIntegerEncoder();
+  const { encodeTextString, encodeByteString } = useCborStringEncoder(options);
+  const { encodeArray, encodeMap, setMainEncode } = useCborCollectionEncoder(options);
+  const { encodeSimple, encodeFloat } = useCborSimpleEncoder();
+  const { encodeTaggedValue } = useCborTagEncoder();
+  const { isCborByteString } = chunkPD72MVTX_cjs.useCborByteString();
+  const { isCborTextString } = chunkPD72MVTX_cjs.useCborTextString();
+  const encode = (value) => {
+    if (value === null || value === void 0 || typeof value === "boolean") {
+      return encodeSimple(value);
+    }
+    if (typeof value === "number") {
+      if (Number.isInteger(value) && Number.isSafeInteger(value)) {
+        return encodeInteger(value);
+      }
+      return encodeFloat(value);
+    }
+    if (typeof value === "bigint") {
+      return encodeInteger(value);
+    }
+    if (isCborTextString(value)) {
+      return encodeTextString(value);
+    }
+    if (typeof value === "string") {
+      return encodeTextString(value);
+    }
+    if (isCborByteString(value)) {
+      return encodeByteString(value);
+    }
+    if (value instanceof Uint8Array) {
+      return encodeByteString(value);
+    }
+    if (Array.isArray(value)) {
+      return encodeArray(value);
+    }
+    if (value instanceof Map) {
+      return encodeMap(value);
+    }
+    if (typeof value === "object" && value !== null && "tag" in value && "value" in value && typeof value.tag === "number") {
+      return encodeTaggedValue(value, encode);
+    }
+    if (typeof value === "object" && value !== null) {
+      return encodeMap(value);
+    }
+    throw new Error(`Unsupported value type: ${typeof value}`);
+  };
+  setMainEncode(encode);
+  const encodeToHex = (value) => {
+    return encode(value).hex;
+  };
+  const encodeToBytes = (value) => {
+    return encode(value).bytes;
+  };
+  const encodeSequence = (values) => {
+    const allBytes = [];
+    for (const value of values) {
+      const result = encode(value);
+      allBytes.push(result.bytes);
+    }
+    const totalLength = allBytes.reduce((sum, arr) => sum + arr.length, 0);
+    const concatenated = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const bytes of allBytes) {
+      concatenated.set(bytes, offset);
+      offset += bytes.length;
+    }
+    const hex = Array.from(concatenated).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return {
+      bytes: concatenated,
+      hex
+    };
+  };
+  return {
+    encode,
+    encodeToHex,
+    encodeToBytes,
+    encodeSequence
+  };
+}
+
+exports.DEFAULT_ENCODE_OPTIONS = DEFAULT_ENCODE_OPTIONS;
+exports.bytesToHex = bytesToHex;
+exports.compareBytes = compareBytes;
+exports.concatenateUint8Arrays = concatenateUint8Arrays;
+exports.useCborCollectionEncoder = useCborCollectionEncoder;
+exports.useCborEncoder = useCborEncoder;
+exports.useCborIntegerEncoder = useCborIntegerEncoder;
+exports.useCborSimpleEncoder = useCborSimpleEncoder;
+exports.useCborStringEncoder = useCborStringEncoder;
+exports.useCborTagEncoder = useCborTagEncoder;
+exports.writeBigUint = writeBigUint;
+exports.writeUint = writeUint;
+//# sourceMappingURL=chunk-2FUTHZQQ.cjs.map
+//# sourceMappingURL=chunk-2FUTHZQQ.cjs.map