@marcuspuchalla/nachos 0.1.0

package/dist/encoder/index.d.ts

@@ -0,0 +1,72 @@
+import { E as EncodableValue, b as EncodeResult, T as TaggedValue } from '../useCborSimpleEncoder-TVxzNJ_9.js';
+export { D as DEFAULT_ENCODE_OPTIONS, g as EncodeContext, a as EncodeOptions, e as useCborCollectionEncoder, u as useCborEncoder, c as useCborIntegerEncoder, f as useCborSimpleEncoder, d as useCborStringEncoder } from '../useCborSimpleEncoder-TVxzNJ_9.js';
+import '../types-DvNlfbKB.js';
+
+/**
+ * CBOR Tag Encoder Composable
+ * Handles Major Type 6 (Semantic Tags)
+ * Following RFC 8949 specification
+ */
+
+/**
+ * CBOR Tag Encoder Composable
+ *
+ * Provides functions to encode tagged values to CBOR format:
+ * - Major Type 6: Semantic tags (0 to 2^64-1)
+ *
+ * Tags provide semantic meaning to CBOR values:
+ * - Tag 0: Date/time string (RFC 3339)
+ * - Tag 1: Epoch timestamp
+ * - Tag 2: Positive bignum
+ * - Tag 3: Negative bignum
+ * - Tag 258: Cardano set (CIP-0005)
+ * - And many more...
+ *
+ * @example
+ * ```ts
+ * const { encodeTag } = useCborTagEncoder()
+ *
+ * // Encode date/time string (tag 0)
+ * const result1 = encodeTag(0, '2013-03-21T20:04:00Z', encode)
+ * // result1.hex: 'c074323031332d30332d32315432303a30343a30305a'
+ *
+ * // Encode positive bignum (tag 2)
+ * const result2 = encodeTag(2, new Uint8Array([0x01, 0xff]), encode)
+ * // result2.hex: 'c24201ff'
+ *
+ * // Encode Cardano set (tag 258)
+ * const result3 = encodeTag(258, [1, 2, 3], encode)
+ * // result3.hex: 'd9010283010203'
+ * ```
+ */
+declare function useCborTagEncoder(): {
+    encodeTagNumber: (tagNumber: number | bigint) => Uint8Array;
+    encodeTag: (tagNumber: number | bigint, value: EncodableValue, encode: (value: EncodableValue) => EncodeResult) => EncodeResult;
+    encodeTaggedValue: (taggedValue: TaggedValue, encode: (value: EncodableValue) => EncodeResult) => EncodeResult;
+};
+
+/**
+ * CBOR Encoder Utility Functions
+ */
+/**
+ * Convert Uint8Array to hex string
+ */
+declare function bytesToHex(bytes: Uint8Array): string;
+/**
+ * Concatenate multiple Uint8Arrays
+ */
+declare function concatenateUint8Arrays(arrays: Uint8Array[]): Uint8Array;
+/**
+ * Compare two Uint8Arrays bytewise (for canonical map sorting)
+ */
+declare function compareBytes(a: Uint8Array, b: Uint8Array): number;
+/**
+ * Write unsigned integer to bytes (big-endian)
+ */
+declare function writeUint(value: number, bytes: number): Uint8Array;
+/**
+ * Write BigInt to bytes (big-endian)
+ */
+declare function writeBigUint(value: bigint, bytes: number): Uint8Array;
+
+export { EncodableValue, EncodeResult, bytesToHex, compareBytes, concatenateUint8Arrays, useCborTagEncoder, writeBigUint, writeUint };

package/dist/encoder/index.js

@@ -0,0 +1,4 @@
+export { DEFAULT_ENCODE_OPTIONS, bytesToHex, compareBytes, concatenateUint8Arrays, useCborCollectionEncoder, useCborEncoder, useCborIntegerEncoder, useCborSimpleEncoder, useCborStringEncoder, useCborTagEncoder, writeBigUint, writeUint } from '../chunk-7CFYWHS6.js';
+import '../chunk-ZDZ2B5PE.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/encoder/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/index.cjs

@@ -0,0 +1,606 @@
+'use strict';
+
+var chunk2HBCILJS_cjs = require('./chunk-2HBCILJS.cjs');
+var chunk2FUTHZQQ_cjs = require('./chunk-2FUTHZQQ.cjs');
+var chunkPD72MVTX_cjs = require('./chunk-PD72MVTX.cjs');
+
+// src/parser/composables/useCborDiagnostic.ts
+function isTaggedValue(value) {
+  return typeof value === "object" && value !== null && "tag" in value && "value" in value && typeof value.tag === "number";
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Uint8Array) && !(value instanceof Map) && !(value instanceof Set) && !isTaggedValue(value) && value.constructor === Object;
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/[\x00-\x1f\x7f-\x9f]/g, (char) => {
+    const code = char.charCodeAt(0);
+    return `\\u${code.toString(16).padStart(4, "0")}`;
+  });
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function useCborDiagnostic() {
+  const toDiagnostic2 = (value, options = {}) => {
+    const {
+      pretty = false,
+      indent = "  ",
+      maxDepth = 100,
+      indefinite = false
+    } = options;
+    return formatValue(value, 0, pretty, indent, maxDepth, indefinite);
+  };
+  const formatValue = (value, depth, pretty, indent, maxDepth, indefinite) => {
+    if (depth > maxDepth) {
+      return "...";
+    }
+    if (value === null) {
+      return "null";
+    }
+    if (value === void 0) {
+      return "undefined";
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    if (typeof value === "number") {
+      if (Number.isNaN(value)) {
+        return "NaN";
+      }
+      if (value === Infinity) {
+        return "Infinity";
+      }
+      if (value === -Infinity) {
+        return "-Infinity";
+      }
+      if (Object.is(value, -0)) {
+        return "-0.0";
+      }
+      if (Number.isInteger(value)) {
+        return value.toString();
+      }
+      return value.toString();
+    }
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (typeof value === "string") {
+      return `"${escapeString(value)}"`;
+    }
+    if (value instanceof Uint8Array) {
+      return `h'${bytesToHex(value)}'`;
+    }
+    if (isTaggedValue(value)) {
+      const taggedContent = formatValue(
+        value.value,
+        depth + 1,
+        pretty,
+        indent,
+        maxDepth,
+        false
+      );
+      return `${value.tag}(${taggedContent})`;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return indefinite ? "[_ ]" : "[]";
+      }
+      const items = value.map(
+        (item) => formatValue(item, depth + 1, pretty, indent, maxDepth, false)
+      );
+      if (pretty) {
+        const prefix = indefinite ? "[_ " : "[";
+        const lineIndent = indent.repeat(depth + 1);
+        const closeIndent = indent.repeat(depth);
+        return `${prefix}
+${lineIndent}${items.join(`,
+${lineIndent}`)}
+${closeIndent}]`;
+      } else {
+        const prefix = indefinite ? "[_ " : "[";
+        return `${prefix}${items.join(", ")}]`;
+      }
+    }
+    if (value instanceof Map) {
+      if (value.size === 0) {
+        return indefinite ? "{_ }" : "{}";
+      }
+      const entries = [];
+      for (const [k, v] of value) {
+        const keyStr = formatValue(k, depth + 1, pretty, indent, maxDepth, false);
+        const valueStr = formatValue(v, depth + 1, pretty, indent, maxDepth, false);
+        entries.push(`${keyStr}: ${valueStr}`);
+      }
+      if (pretty) {
+        const prefix = indefinite ? "{_ " : "{";
+        const lineIndent = indent.repeat(depth + 1);
+        const closeIndent = indent.repeat(depth);
+        return `${prefix}
+${lineIndent}${entries.join(`,
+${lineIndent}`)}
+${closeIndent}}`;
+      } else {
+        const prefix = indefinite ? "{_ " : "{";
+        return `${prefix}${entries.join(", ")}}`;
+      }
+    }
+    if (value instanceof Set) {
+      const items = Array.from(value).map(
+        (item) => formatValue(item, depth + 1, pretty, indent, maxDepth, false)
+      );
+      if (pretty) {
+        const lineIndent = indent.repeat(depth + 1);
+        const closeIndent = indent.repeat(depth);
+        return `[
+${lineIndent}${items.join(`,
+${lineIndent}`)}
+${closeIndent}]`;
+      } else {
+        return `[${items.join(", ")}]`;
+      }
+    }
+    if (isPlainObject(value)) {
+      const keys = Object.keys(value);
+      if (keys.length === 0) {
+        return indefinite ? "{_ }" : "{}";
+      }
+      const entries = keys.map((key) => {
+        const keyStr = `"${escapeString(key)}"`;
+        const valueStr = formatValue(
+          value[key],
+          depth + 1,
+          pretty,
+          indent,
+          maxDepth,
+          false
+        );
+        return `${keyStr}: ${valueStr}`;
+      });
+      if (pretty) {
+        const prefix = indefinite ? "{_ " : "{";
+        const lineIndent = indent.repeat(depth + 1);
+        const closeIndent = indent.repeat(depth);
+        return `${prefix}
+${lineIndent}${entries.join(`,
+${lineIndent}`)}
+${closeIndent}}`;
+      } else {
+        const prefix = indefinite ? "{_ " : "{";
+        return `${prefix}${entries.join(", ")}}`;
+      }
+    }
+    return String(value);
+  };
+  const fromDiagnostic = (diag) => {
+    const trimmed = diag.trim();
+    if (trimmed === "null") return null;
+    if (trimmed === "undefined") return void 0;
+    if (trimmed === "true") return true;
+    if (trimmed === "false") return false;
+    if (trimmed === "NaN") return NaN;
+    if (trimmed === "Infinity") return Infinity;
+    if (trimmed === "-Infinity") return -Infinity;
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+      const num = Number(trimmed);
+      if (trimmed === "-0.0" || trimmed === "-0") {
+        return -0;
+      }
+      return num;
+    }
+    const hexMatch = trimmed.match(/^h'([0-9a-fA-F]*)'$/);
+    if (hexMatch && hexMatch[1] !== void 0) {
+      const hex = hexMatch[1];
+      const bytes = new Uint8Array(hex.length / 2);
+      for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+      }
+      return bytes;
+    }
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+      return trimmed.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    return trimmed;
+  };
+  const toDiagnosticWithType = (value, majorType, options = {}) => {
+    const typeNames = {
+      0: "uint",
+      1: "nint",
+      2: "bstr",
+      3: "tstr",
+      4: "array",
+      5: "map",
+      6: "tag",
+      7: "simple"
+    };
+    const typeName = typeNames[majorType] || "unknown";
+    const diag = toDiagnostic2(value, options);
+    return `${typeName}(${diag})`;
+  };
+  return {
+    toDiagnostic: toDiagnostic2,
+    fromDiagnostic,
+    toDiagnosticWithType
+  };
+}
+
+// src/parser/utils/pathBuilder.ts
+var PathBuilder = {
+  /**
+   * Create root path (empty string)
+   */
+  root: () => "",
+  /**
+   * Create path for array index
+   * @param parent - Parent path
+   * @param index - Array index (0-based)
+   * @returns Path string like "[0]" or "[0][1]"
+   */
+  arrayIndex: (parent, index) => `${parent}[${index}]`,
+  /**
+   * Create path for map/object key
+   * @param parent - Parent path
+   * @param key - Key name (string or number)
+   * @returns Path string like ".key" or "[0].key"
+   */
+  mapKey: (parent, key) => {
+    const keyStr = String(key);
+    const escapedKey = keyStr.replace(/[.\[\]\\]/g, "\\$&");
+    return parent ? `${parent}.${escapedKey}` : `.${escapedKey}`;
+  },
+  /**
+   * Create path for map key by index (for non-string keys)
+   * @param parent - Parent path
+   * @param index - Key index in map
+   * @returns Path string like "[#key:0]"
+   */
+  mapKeyIndex: (parent, index) => `${parent}[#key:${index}]`,
+  /**
+   * Create path for header portion of a value
+   * Used for byte strings, text strings, arrays, maps, tags
+   * @param parent - Parent path
+   * @returns Path string like "[0][#header]"
+   */
+  header: (parent) => `${parent}[#header]`,
+  /**
+   * Create path for content portion of a value
+   * Used for byte strings and text strings
+   * @param parent - Parent path
+   * @returns Path string like "[0][#content]"
+   */
+  content: (parent) => `${parent}[#content]`,
+  /**
+   * Create path for tagged value
+   * @param parent - Parent path
+   * @returns Path string like "[0][#value]"
+   */
+  tagValue: (parent) => `${parent}[#value]`,
+  /**
+   * Normalize a path by removing special markers (#header, #content, #value)
+   * Used for matching paths across different representations
+   * @param path - Path to normalize
+   * @returns Normalized path without special markers
+   */
+  normalize: (path) => {
+    return path.replace(/\[#(header|content|value)\]$/, "");
+  },
+  /**
+   * Check if path is a header path
+   * @param path - Path to check
+   * @returns True if path ends with [#header]
+   */
+  isHeader: (path) => path.endsWith("[#header]"),
+  /**
+   * Check if path is a content path
+   * @param path - Path to check
+   * @returns True if path ends with [#content]
+   */
+  isContent: (path) => path.endsWith("[#content]"),
+  /**
+   * Check if path is a tag value path
+   * @param path - Path to check
+   * @returns True if path ends with [#value]
+   */
+  isTagValue: (path) => path.endsWith("[#value]"),
+  /**
+   * Check if path has any special marker
+   * @param path - Path to check
+   * @returns True if path ends with any special marker
+   */
+  hasMarker: (path) => /\[#(header|content|value)\]$/.test(path),
+  /**
+   * Get parent path (one level up)
+   * @param path - Path to get parent of
+   * @returns Parent path or null if already at root
+   */
+  getParent: (path) => {
+    const normalized = PathBuilder.normalize(path);
+    if (normalized === "") return null;
+    const arrayMatch = normalized.match(/^(.+)\[\d+\]$/);
+    if (arrayMatch && arrayMatch[1] !== void 0) return arrayMatch[1];
+    const keyMatch = normalized.match(/^(.+)\.[^.]+$/);
+    if (keyMatch && keyMatch[1] !== void 0) return keyMatch[1];
+    if (normalized.startsWith("[") || normalized.startsWith(".")) {
+      return "";
+    }
+    return null;
+  },
+  /**
+   * Get the depth (nesting level) of a path
+   * @param path - Path to measure
+   * @returns Number indicating nesting depth (0 for root)
+   */
+  getDepth: (path) => {
+    const normalized = PathBuilder.normalize(path);
+    if (normalized === "") return 0;
+    const arrayDepth = (normalized.match(/\[\d+\]/g) || []).length;
+    const keyDepth = (normalized.match(/\./g) || []).length;
+    return arrayDepth + keyDepth;
+  },
+  /**
+   * Parse a path into its components
+   * @param path - Path to parse
+   * @returns Array of path segments
+   */
+  parse: (path) => {
+    const normalized = PathBuilder.normalize(path);
+    const segments = [];
+    const markerMatch = path.match(/\[#(header|content|value)\]$/);
+    let remaining = normalized;
+    while (remaining) {
+      const indexMatch = remaining.match(/^\[(\d+)\]/);
+      if (indexMatch && indexMatch[1] !== void 0) {
+        segments.push({ type: "index", value: parseInt(indexMatch[1], 10) });
+        remaining = remaining.slice(indexMatch[0].length);
+        continue;
+      }
+      const keyMatch = remaining.match(/^\.([^.\[\]]+)/);
+      if (keyMatch && keyMatch[1] !== void 0) {
+        const key = keyMatch[1].replace(/\\(.)/g, "$1");
+        segments.push({ type: "key", value: key });
+        remaining = remaining.slice(keyMatch[0].length);
+        continue;
+      }
+      break;
+    }
+    if (markerMatch && markerMatch[1] !== void 0) {
+      segments.push({ type: "marker", value: markerMatch[1] });
+    }
+    return segments;
+  },
+  /**
+   * Build a path from segments
+   * @param segments - Array of path segments
+   * @returns Path string
+   */
+  build: (segments) => {
+    let path = "";
+    for (const segment of segments) {
+      if (segment.type === "index") {
+        path += `[${segment.value}]`;
+      } else if (segment.type === "key") {
+        const escapedKey = String(segment.value).replace(/[.\[\]\\]/g, "\\$&");
+        path += `.${escapedKey}`;
+      } else if (segment.type === "marker") {
+        path += `[#${segment.value}]`;
+      }
+    }
+    return path;
+  },
+  /**
+   * Join multiple path segments
+   * @param paths - Path segments to join
+   * @returns Combined path
+   */
+  join: (...paths) => {
+    return paths.filter((p) => p !== "").join("");
+  },
+  /**
+   * Check if a path is a descendant of another path
+   * @param path - Path to check
+   * @param ancestor - Potential ancestor path
+   * @returns True if path is a descendant of ancestor
+   */
+  isDescendantOf: (path, ancestor) => {
+    const normalizedPath = PathBuilder.normalize(path);
+    const normalizedAncestor = PathBuilder.normalize(ancestor);
+    if (normalizedAncestor === "") {
+      return normalizedPath !== "";
+    }
+    return normalizedPath.startsWith(normalizedAncestor) && normalizedPath.length > normalizedAncestor.length && (normalizedPath[normalizedAncestor.length] === "[" || normalizedPath[normalizedAncestor.length] === ".");
+  }
+};
+
+// src/index.ts
+function decode(hexString, options) {
+  const { parse } = chunk2HBCILJS_cjs.useCborParser();
+  return parse(hexString, options);
+}
+function decodeWithSourceMap(hexString, options) {
+  const { parseWithSourceMap } = chunk2HBCILJS_cjs.useCborParser();
+  return parseWithSourceMap(hexString, options);
+}
+function encode(value, options) {
+  const { encode: encodeValue } = chunk2FUTHZQQ_cjs.useCborEncoder(options);
+  return encodeValue(value);
+}
+function encodeToHex(value, options) {
+  const { encodeToHex: encodeValueToHex } = chunk2FUTHZQQ_cjs.useCborEncoder(options);
+  return encodeValueToHex(value);
+}
+function encodeToBytes(value, options) {
+  const { encodeToBytes: encodeValueToBytes } = chunk2FUTHZQQ_cjs.useCborEncoder(options);
+  return encodeValueToBytes(value);
+}
+function encodeSequence(values, options) {
+  const { encodeSequence: encodeSeq } = chunk2FUTHZQQ_cjs.useCborEncoder(options);
+  return encodeSeq(values);
+}
+var CborDecoder = class {
+  /**
+   * Create a new CBOR decoder
+   *
+   * @param options - Parser configuration
+   */
+  constructor(options) {
+    this.options = options || {};
+  }
+  /**
+   * Decode CBOR hex string
+   *
+   * @param hexString - CBOR data as hex string
+   * @returns Decoded value and byte count
+   */
+  decode(hexString) {
+    return decode(hexString, this.options);
+  }
+  /**
+   * Decode CBOR hex string with source map
+   *
+   * @param hexString - CBOR data as hex string
+   * @returns Decoded value, byte count, and source map
+   */
+  decodeWithSourceMap(hexString) {
+    return decodeWithSourceMap(hexString, this.options);
+  }
+};
+var CborEncoder = class {
+  /**
+   * Create a new CBOR encoder
+   *
+   * @param options - Encoder configuration
+   */
+  constructor(options) {
+    this.options = options || {};
+  }
+  /**
+   * Encode value to CBOR
+   *
+   * @param value - JavaScript value to encode
+   * @returns CBOR bytes and hex string
+   */
+  encode(value) {
+    return encode(value, this.options);
+  }
+  /**
+   * Encode value to CBOR hex string
+   *
+   * @param value - JavaScript value to encode
+   * @returns CBOR hex string
+   */
+  encodeToHex(value) {
+    return encodeToHex(value, this.options);
+  }
+  /**
+   * Encode value to CBOR bytes
+   *
+   * @param value - JavaScript value to encode
+   * @returns CBOR bytes
+   */
+  encodeToBytes(value) {
+    return encodeToBytes(value, this.options);
+  }
+  /**
+   * Encode multiple values as CBOR sequence
+   *
+   * @param values - Array of values to encode
+   * @returns Concatenated CBOR encoding
+   */
+  encodeSequence(values) {
+    return encodeSequence(values, this.options);
+  }
+};
+function toDiagnostic(value, options) {
+  const { toDiagnostic: convert } = useCborDiagnostic();
+  return convert(value, options);
+}
+function decodeToDiagnostic(hexString, options) {
+  const { value } = decode(hexString);
+  return toDiagnostic(value, options);
+}
+
+Object.defineProperty(exports, "useCborCollection", {
+  enumerable: true,
+  get: function () { return chunk2HBCILJS_cjs.useCborCollection; }
+});
+Object.defineProperty(exports, "useCborFloat", {
+  enumerable: true,
+  get: function () { return chunk2HBCILJS_cjs.useCborFloat; }
+});
+Object.defineProperty(exports, "useCborInteger", {
+  enumerable: true,
+  get: function () { return chunk2HBCILJS_cjs.useCborInteger; }
+});
+Object.defineProperty(exports, "useCborParser", {
+  enumerable: true,
+  get: function () { return chunk2HBCILJS_cjs.useCborParser; }
+});
+Object.defineProperty(exports, "useCborString", {
+  enumerable: true,
+  get: function () { return chunk2HBCILJS_cjs.useCborString; }
+});
+Object.defineProperty(exports, "useCborTag", {
+  enumerable: true,
+  get: function () { return chunk2HBCILJS_cjs.useCborTag; }
+});
+Object.defineProperty(exports, "DEFAULT_ENCODE_OPTIONS", {
+  enumerable: true,
+  get: function () { return chunk2FUTHZQQ_cjs.DEFAULT_ENCODE_OPTIONS; }
+});
+Object.defineProperty(exports, "useCborCollectionEncoder", {
+  enumerable: true,
+  get: function () { return chunk2FUTHZQQ_cjs.useCborCollectionEncoder; }
+});
+Object.defineProperty(exports, "useCborEncoder", {
+  enumerable: true,
+  get: function () { return chunk2FUTHZQQ_cjs.useCborEncoder; }
+});
+Object.defineProperty(exports, "useCborIntegerEncoder", {
+  enumerable: true,
+  get: function () { return chunk2FUTHZQQ_cjs.useCborIntegerEncoder; }
+});
+Object.defineProperty(exports, "useCborSimpleEncoder", {
+  enumerable: true,
+  get: function () { return chunk2FUTHZQQ_cjs.useCborSimpleEncoder; }
+});
+Object.defineProperty(exports, "useCborStringEncoder", {
+  enumerable: true,
+  get: function () { return chunk2FUTHZQQ_cjs.useCborStringEncoder; }
+});
+Object.defineProperty(exports, "CborAdditionalInfo", {
+  enumerable: true,
+  get: function () { return chunkPD72MVTX_cjs.CborAdditionalInfo; }
+});
+Object.defineProperty(exports, "CborMajorType", {
+  enumerable: true,
+  get: function () { return chunkPD72MVTX_cjs.CborMajorType; }
+});
+Object.defineProperty(exports, "CborSimpleValue", {
+  enumerable: true,
+  get: function () { return chunkPD72MVTX_cjs.CborSimpleValue; }
+});
+Object.defineProperty(exports, "CborTag", {
+  enumerable: true,
+  get: function () { return chunkPD72MVTX_cjs.CborTag; }
+});
+Object.defineProperty(exports, "DEFAULT_LIMITS", {
+  enumerable: true,
+  get: function () { return chunkPD72MVTX_cjs.DEFAULT_LIMITS; }
+});
+Object.defineProperty(exports, "DEFAULT_OPTIONS", {
+  enumerable: true,
+  get: function () { return chunkPD72MVTX_cjs.DEFAULT_OPTIONS; }
+});
+exports.CborDecoder = CborDecoder;
+exports.CborEncoder = CborEncoder;
+exports.PathBuilder = PathBuilder;
+exports.decode = decode;
+exports.decodeToDiagnostic = decodeToDiagnostic;
+exports.decodeWithSourceMap = decodeWithSourceMap;
+exports.encode = encode;
+exports.encodeSequence = encodeSequence;
+exports.encodeToBytes = encodeToBytes;
+exports.encodeToHex = encodeToHex;
+exports.toDiagnostic = toDiagnostic;
+exports.useCborDiagnostic = useCborDiagnostic;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map