@cbortech/cbor 0.26.7 → 0.26.8

package/dist/mapEntries-BJzyBUH5.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapEntries-BJzyBUH5.cjs","names":[],"sources":["../src/tag.ts","../src/types.ts","../src/simple.ts","../src/utils/float16.ts","../src/cbor/encode.ts","../src/ast/CborItem.ts","../src/ast/CborUint.ts","../src/ast/CborNint.ts","../src/utils/hexfloat.ts","../src/ast/CborFloat.ts","../src/ast/CborTag.ts","../src/ast/CborByteString.ts","../src/ast/CborIndefiniteByteString.ts","../src/ast/CborIndefiniteTextString.ts","../src/ast/CborArray.ts","../src/ast/CborMap.ts","../src/ast/CborSimple.ts","../src/ast/CborEmbeddedCBOR.ts","../src/utils/strip-comments.ts","../src/extensions/b32.ts","../src/utils/base64.ts","../src/ast/CborUnresolvedAppExt.ts","../src/ast/CborAppSeqResult.ts","../src/ast/CborEllipsis.ts","../src/ast/CborBignum.ts","../src/cdn/parser.ts","../src/ast/CborTextString.ts","../src/extensions/dt.ts","../src/utils/ip.ts","../src/extensions/ip.ts","../src/extensions/cri.ts","../src/extensions/bignum.ts","../src/cbor/decoder.ts","../src/extensions/cbordata.ts","../src/extensions/ellipsis.ts","../src/extensions/concat.ts","../src/extensions/ilstrings.ts","../src/extensions/float.ts","../src/extensions/builtins.ts","../src/js/fromJS.ts","../src/mapEntries.ts"],"sourcesContent":["export const CBOR_TAG: unique symbol = Symbol.for('cbor.tag');\n\n// ─── Internal wrappers ────────────────────────────────────────────────────────\n\nexport class Null {\n  valueOf(): null {\n    return null;\n  }\n  toJSON(): null {\n    return null;\n  }\n}\n\nexport class Undefined {\n  valueOf(): undefined {\n    return undefined;\n  }\n  toJSON(): undefined {\n    return undefined;\n  }\n}\n\n// ─── Public helpers ───────────────────────────────────────────────────────────\n\n/** @internal */\nexport function getCborTag(value: unknown): bigint | undefined {\n  if (!_canHaveTag(value)) return undefined;\n  const sym = (value as Record<symbol, unknown>)[CBOR_TAG];\n  return typeof sym === 'bigint' ? sym : undefined;\n}\n\n/** @internal */\nexport function setCborTag(value: unknown, tag: bigint): object {\n  let obj: object;\n  switch (typeof value) {\n    case 'number':\n      obj = new Number(value);\n      break;\n    case 'string':\n      obj = new String(value);\n      break;\n    case 'boolean':\n      obj = new Boolean(value);\n      break;\n    case 'bigint':\n      obj = Object(value);\n      break;\n    case 'undefined':\n      obj = new Undefined();\n      break;\n    case 'object':\n      if (value === null) {\n        obj = new Null();\n        break;\n      }\n      obj = value as object;\n      break;\n    default:\n      throw new TypeError(\n        `setCborTag: cannot tag value of type ${typeof value}`\n      );\n  }\n  (obj as Record<symbol, bigint>)[CBOR_TAG] = tag;\n  return obj;\n}\n\n/** @internal */\nexport function removeCborTag(value: unknown): unknown {\n  if (value instanceof Number) return value.valueOf();\n  if (value instanceof String) return value.valueOf();\n  if (value instanceof Boolean) return value.valueOf();\n  if (Object.prototype.toString.call(value) === '[object BigInt]')\n    return (value as { valueOf(): bigint }).valueOf();\n  if (value instanceof Null) return null;\n  if (value instanceof Undefined) return undefined;\n  if (typeof value === 'object' && value !== null) {\n    delete (value as Record<symbol, unknown>)[CBOR_TAG];\n    return value;\n  }\n  return value;\n}\n\n/** @internal */\nexport function getCborTaggedValue(value: unknown): unknown {\n  if (value instanceof Number) return value.valueOf();\n  if (value instanceof String) return value.valueOf();\n  if (value instanceof Boolean) return value.valueOf();\n  if (Object.prototype.toString.call(value) === '[object BigInt]')\n    return (value as { valueOf(): bigint }).valueOf();\n  if (value instanceof Null) return null;\n  if (value instanceof Undefined) return undefined;\n  return value;\n}\n\n// ─── Internal helper ──────────────────────────────────────────────────────────\n\n/** Return true if value can carry the [CBOR_TAG] symbol (i.e. is a non-null object). */\nfunction _canHaveTag(value: unknown): value is object {\n  // All boxed primitives (Number, String, Boolean, BigInt objects) also have\n  // typeof === 'object', so a single check covers all cases.\n  return typeof value === 'object' && value !== null;\n}\n\n// ─── Tag namespace ────────────────────────────────────────────────────────────\n\n/**\n * Namespace for CBOR tag annotation utilities.\n *\n * @example\n * const v = CBOR.fromCDN('42(\"hello\")').toJS();\n * Tag.get(v);        // 42n\n * Tag.getValue(v);   // \"hello\"\n *\n * const tagged = Tag.set([1, 2, 3], 100n);\n * Tag.remove(tagged); // [1, 2, 3]\n */\nexport class Tag {\n  private constructor() {}\n\n  /** Unique symbol used to attach a CBOR tag number to a JS value. */\n  static readonly symbol: typeof CBOR_TAG = CBOR_TAG;\n\n  /** Wrapper class for tagged `null` values. */\n  static readonly Null = Null;\n\n  /** Wrapper class for tagged `undefined` values. */\n  static readonly Undefined = Undefined;\n\n  /** Return the CBOR tag number attached to `value`, or `undefined` if none. */\n  static get(value: unknown): bigint | undefined {\n    return getCborTag(value);\n  }\n\n  /** Attach a CBOR tag number to `value` and return the annotated value. */\n  static set(value: unknown, tag: bigint): object {\n    return setCborTag(value, tag);\n  }\n\n  /** Remove the `[Tag.symbol]` annotation from `value` and return the plain value. */\n  static remove(value: unknown): unknown {\n    return removeCborTag(value);\n  }\n\n  /** Return the underlying plain JS value held inside a tagged wrapper. */\n  static getValue(value: unknown): unknown {\n    return getCborTaggedValue(value);\n  }\n}\n","/**\n * Shared option types and plugin interfaces.\n */\n\n// ─── Omit sentinel ───────────────────────────────────────────────────────────\n\n/**\n * Sentinel returned from a replacer or reviver to omit the key/element from\n * the output.  Use this instead of returning `undefined` when `undefinedOmits`\n * is `false` (the default) and you need to drop a specific entry.\n *\n * Accessible as `CBOR.OMIT` on the main class.\n */\nexport const CBOR_OMIT: unique symbol = Symbol('cbor.omit');\n\n// ─── Extension plugin ─────────────────────────────────────────────────────────\n// Defined in extensions/types.ts and re-exported here for convenience.\nexport type { CborExtension } from './extensions/types';\nimport type { CborExtension } from './extensions/types';\n\n// ─── CDDL ─────────────────────────────────────────────────────────────────────\n// Type-only imports; note however that supporting CDDL source text as the\n// `cddl` option makes the facade (cbor.ts) import the compiler at runtime,\n// so the main entry loads the CDDL chunks as well. Accepting only compiled\n// schemas would keep the compiler exclusive to the `/cddl` subpath.\nimport type { CddlSchema } from './cddl/schema';\nimport type { ValidateOptions as CddlValidateOptions } from './cddl/validator';\nimport type { CddlValidationError, CddlValidationWarning } from './cddl/errors';\n\n// ─── Options ──────────────────────────────────────────────────────────────────\n\nexport interface ToHexDumpOptions {\n  /**\n   * Indentation per nesting level.\n   * - `number`: number of spaces (e.g. `3` → `\"   \"`)\n   * - `string`: literal indent string (e.g. `'\\t'`)\n   * @default 3\n   */\n  indent?: number | string;\n  /** Comment marker used in the hex dump. Default: `'--'` */\n  commentStyle?: '--' | '#';\n}\n\nexport interface ToJSOptions {\n  /**\n   * How to represent CBOR integer values (major type 0 / 1) in JavaScript.\n   * - `'auto'`: `number` when the value is within the safe integer range\n   *   (±`Number.MAX_SAFE_INTEGER`), `bigint` otherwise.\n   * - `'number'`: always `number` (precision may be lost for large values).\n   * - `'bigint'`: always `bigint`.\n   * @default 'auto'\n   */\n  integerAs?: 'auto' | 'number' | 'bigint';\n\n  /**\n   * How to represent CBOR map values when converting to JavaScript.\n   * - `'auto'`: text-string-only keys → `Record<string, unknown>`,\n   *   other key types → `Map<unknown, unknown>`.\n   *   Duplicate keys are silently overwritten (last value wins).\n   * - `'object'`: always `Record<string, unknown>` — non-string keys are\n   *   converted via `String()`. Duplicate keys are overwritten (last wins).\n   * - `'entries'`: always `MapEntries` (a typed `Array` subclass) — preserves all\n   *   entries including duplicate keys (§2.6.3 of draft-ietf-cbor-edn-literals-25).\n   *   `fromJS()` recognises `MapEntries` instances and converts them back to `CborMap`.\n   * @default 'auto'\n   */\n  mapAs?: 'auto' | 'object' | 'entries';\n\n  /**\n   * When `true`, CBOR tag annotations are omitted from the JavaScript value.\n   *\n   * By default, generic tags are preserved using `CBOR.Tag` so that\n   * `toJS()` → `fromJS()` can round-trip CBOR tags. Enable this option when\n   * you only need the tagged content as a plain JavaScript value.\n   *\n   * @default false\n   */\n  stripTags?: boolean;\n\n  /**\n   * Post-conversion reviver function, applied bottom-up after the CBOR value\n   * has been converted to JavaScript.\n   *\n   * Called for every key/value pair — including map entries with non-string\n   * keys — and finally for the root value with key `''`.\n   * Return `CBOR.OMIT` to remove the entry from its parent container.\n   * When `undefinedOmits` is `true`, returning `undefined` also removes the\n   * entry (matching `JSON.parse` behavior).\n   *\n   * Note: this option is honoured by `CborItem.toJS()` and the `CBOR.*`\n   * shortcut methods.  Calling `_toJS()` directly bypasses it.\n   */\n  reviver?: (this: unknown, key: unknown, value: unknown) => unknown;\n\n  /**\n   * When `true`, a reviver returning `undefined` removes the entry from its\n   * parent container, matching `JSON.parse` behavior.\n   * When `false` (default), only `CBOR.OMIT` removes an entry; returning\n   * `undefined` keeps the entry as CBOR `undefined` (simple 23).\n   * @default false\n   */\n  undefinedOmits?: boolean;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface ToCBOROptions {}\n\n/**\n * A CBOR validity violation detected during decoding.\n */\nexport interface DecodeWarning {\n  /** Human-readable description of the violation. */\n  message: string;\n  /** Byte offset within the decoded input where the violation was detected. */\n  offset: number;\n}\n\n/**\n * A CDN/EDN validity violation detected during parsing.\n */\nexport interface ParseWarning {\n  /** Human-readable description of the violation. */\n  message: string;\n  /** Character offset within the input text where the violation was detected. */\n  offset?: number;\n  /** Line number (1-based) where the violation was detected. */\n  line?: number;\n  /** Column number (1-based) where the violation was detected. */\n  column?: number;\n  /**\n   * Character offset just past the end of the offending range, when the\n   * violation is attributable to a specific token. Lets tooling underline\n   * the exact range instead of a single position.\n   */\n  endOffset?: number;\n  /**\n   * `true` when the violation is a hard syntax error that stopped parsing\n   * (emitted by non-strict sequence parsing, which reports the failure as a\n   * warning and abandons the rest of the input). Tooling should present\n   * fatal warnings as errors.\n   */\n  fatal?: boolean;\n\n  /**\n   * `true` when this entry is an informational hint (e.g. an app-string\n   * prefix matches a known optional extension that isn't registered) rather\n   * than a validity violation. Parsing is unaffected either way, but tooling\n   * that treats `onWarning` calls as failures (see `CBOR.validate()`) should\n   * not count these against validity.\n   */\n  hint?: boolean;\n\n  /**\n   * For a `fatal` warning built from a caught syntax error (see\n   * `CdnSyntaxError`), the original error object with its position fields\n   * intact. `CBOR.validate()` promotes this into `ValidateResult.error`.\n   */\n  cause?: Error;\n}\n\nexport interface FromCBOROptions {\n  /**\n   * Byte offset within the supplied input at which CBOR decoding starts.\n   * Useful for reading one item from a CBOR Sequence.\n   *\n   * @default 0\n   */\n  offset?: number;\n\n  /**\n   * Allow bytes after the decoded item.\n   *\n   * When `false`, decoding still requires the item to consume the remaining\n   * input, preserving the historical single-item behaviour. With `strict: false`\n   * a trailing byte becomes a recoverable warning rather than an error, but\n   * truly malformed trailing data (e.g. truncated items) still throws. Set this\n   * to `true` when using `CborItem.end` to continue decoding a CBOR Sequence.\n   *\n   * @example\n   * // Read two items from a CBOR Sequence, validating that the second is last.\n   * const first = CBOR.fromCBOR(bytes, { allowTrailing: true });\n   * const second = CBOR.fromCBOR(bytes, { offset: first.end });\n   *\n   * @default false\n   */\n  allowTrailing?: boolean;\n\n  /**\n   * Extension plugins applied during CBOR decoding.\n   * Extensions with `parseTag()` are invoked when a tagged item is\n   * encountered; returning a non-`undefined` value replaces the default\n   * `CborTag` node.\n   */\n  extensions?: CborExtension[];\n\n  /**\n   * Override the default set of bundled application-oriented extensions\n   * (`dt`, `ip`, `cri`, `t1`, `b1`, `ilbs`, `ilts`, `float`).\n   *\n   * - omitted (default): use the standard bundled set.\n   * - array: replace the bundled set with exactly these extensions.\n   * - `false`: disable all of them.\n   *\n   * `bignum` (tags 2/3) and embedded-CBOR (tag 24) support are core RFC 8949\n   * representation features, not application-oriented extensions, and are\n   * always active regardless of this option.\n   *\n   * `dt`, `ip`, `t1`, and `b1` are mandatory-to-implement per §2.1 of\n   * draft-ietf-cbor-edn-literals-26; disabling them produces a decoder that\n   * no longer conforms to that recommendation. This is intended for\n   * allowlisting scenarios (see §7 Security considerations of the same\n   * draft) where an application wants explicit control over which\n   * extensions it accepts.\n   */\n  builtinExtensions?: CborExtension[] | false;\n\n  /**\n   * Controls how CBOR validity violations are handled.\n   *\n   * - `true` (default): violations call `onWarning` and then throw, stopping\n   *   decoding immediately.\n   * - `false`: recoverable violations call `onWarning` and decoding continues\n   *   with a best-effort interpretation of the data.\n   *\n   * Truly malformed data (e.g. truncated input, reserved AI values) always\n   * throws regardless of this setting. Trailing bytes after a successfully\n   * decoded item are a recoverable violation and are therefore controlled by\n   * this flag.\n   *\n   * @default true\n   */\n  strict?: boolean;\n\n  /**\n   * Callback invoked when a CBOR validity violation is detected.\n   *\n   * In strict mode (the default), this is called before the error is thrown.\n   * In non-strict mode (`strict: false`), this is called and decoding\n   * continues.\n   *\n   * If not supplied and `silent` is not `true`, violations are reported via\n   * `console.warn`.\n   */\n  onWarning?: (warning: DecodeWarning) => void;\n\n  /**\n   * When `true`, suppresses the default `console.warn` output for validity\n   * violations.  An explicit `onWarning` callback is still invoked even when\n   * `silent` is `true`.\n   *\n   * @default false\n   */\n  silent?: boolean;\n\n  /**\n   * CDDL schema to validate decoded items against: either a compiled schema\n   * (`CDDL.compile()` from `@cbortech/cbor/cddl`) or CDDL source text.\n   * Source text is compiled on first use with default compile options and\n   * cached, so passing the same string repeatedly does not recompile; pass a\n   * compiled schema to control `CompileOptions` yourself. Invalid CDDL text\n   * throws `CddlSyntaxError` / `CddlSemanticError` at the call site.\n   *\n   * Each decoded item is validated after decoding, against the schema's\n   * root rule by default (or `cddlValidationOptions.rule`, if set); a\n   * mismatch throws {@link CddlMismatchError}. Sequence entry points\n   * (`fromCBORSeq`, `decodeSeq`, …) validate each item of the sequence\n   * individually against that same rule. `CBOR.validate()` collects\n   * mismatches into `ValidateResult.cddlErrors` instead of throwing.\n   */\n  cddl?: CddlSchema | string;\n\n  /**\n   * Options forwarded to the CDDL validator when `cddl` is supplied\n   * (`features` for the `.feature` control operator, `maxDepth`,\n   * `maxSteps`, and `rule` to validate against a rule other than the\n   * schema's root). Ignored without `cddl`.\n   */\n  cddlValidationOptions?: CddlValidateOptions;\n}\n\n/**\n * Options for parsing an annotated hex dump.\n */\nexport interface FromHexDumpOptions {\n  /**\n   * Extension plugins applied during CBOR decoding.\n   * Extensions with `parseTag()` are invoked when a tagged item is encountered;\n   * returning a non-`undefined` value replaces the default `CborTag` node.\n   */\n  extensions?: CborExtension[];\n\n  /**\n   * Override the default set of bundled application-oriented extensions.\n   * Mirrors `FromCBOROptions.builtinExtensions`.\n   */\n  builtinExtensions?: CborExtension[] | false;\n\n  /**\n   * Controls how CBOR validity violations are handled during hex-dump decoding.\n   * Mirrors `FromCBOROptions.strict`. With `strict: false`, trailing bytes after\n   * the first decoded item (i.e. a CBOR Sequence) emit a warning instead of\n   * throwing, allowing the first item to be returned.\n   *\n   * @default true\n   */\n  strict?: boolean;\n\n  /**\n   * Callback invoked when a CBOR validity violation is detected.\n   * Mirrors `FromCBOROptions.onWarning`.\n   */\n  onWarning?: (warning: DecodeWarning) => void;\n\n  /**\n   * When `true`, suppresses the default `console.warn` output for violations.\n   * Mirrors `FromCBOROptions.silent`.\n   *\n   * @default false\n   */\n  silent?: boolean;\n\n  /**\n   * Compiled CDDL schema to validate decoded items against.\n   * Mirrors `FromCBOROptions.cddl`.\n   */\n  cddl?: CddlSchema | string;\n\n  /**\n   * Options forwarded to the CDDL validator.\n   * Mirrors `FromCBOROptions.cddlValidationOptions`.\n   */\n  cddlValidationOptions?: CddlValidateOptions;\n}\n\nexport interface FromCDNOptions {\n  /**\n   * Character offset within the supplied text at which CDN parsing starts.\n   * Leading whitespace/comments at or after this offset are skipped as usual.\n   *\n   * @default 0\n   */\n  offset?: number;\n\n  /**\n   * Allow tokens after the parsed item.\n   *\n   * When `false`, parsing still requires the item to consume the remaining\n   * input, preserving the historical single-item behaviour. With `strict: false`\n   * a trailing token becomes a recoverable warning rather than an error, but\n   * hard lexer errors in the trailing content (e.g. unterminated strings) still\n   * throw. Set this to `true` when using `CborItem.end` to continue parsing a\n   * CDN sequence.\n   * Top-level comma separators are not skipped by `fromCDN()` itself; handle\n   * them in sequence-level code before passing the next `offset`. For example,\n   * after parsing `1, 2`, the first item's `end` points just before the comma;\n   * advance past that comma before parsing the next item.\n   *\n   * @example\n   * // Read two whitespace-separated items, validating that the second is last.\n   * const first = CBOR.fromCDN(text, { allowTrailing: true });\n   * const second = CBOR.fromCDN(text, { offset: first.end });\n   *\n   * @default false\n   */\n  allowTrailing?: boolean;\n\n  /**\n   * Extension plugins for CDN parsing.\n   * Each extension declares which app-string prefixes (and, in future, tag\n   * numbers) it handles via `appStringPrefixes` / `tagNumbers`, and provides\n   * callback methods that return `CborItem`-subclassed objects controlling\n   * subsequent serialisation.\n   *\n   * User-supplied extensions take priority over the built-in `dt`/`DT`\n   * extension for the same prefix.\n   */\n  extensions?: CborExtension[];\n\n  /**\n   * Override the default set of bundled application-oriented extensions\n   * (`dt`, `ip`, `cri`, `t1`, `b1`, `ilbs`, `ilts`, `float`).\n   *\n   * - omitted (default): use the standard bundled set.\n   * - array: replace the bundled set with exactly these extensions.\n   * - `false`: disable all of them; app-string literals using their\n   *   prefixes then fall through to `unresolvedExtension` handling.\n   *\n   * `dt`, `ip`, `t1`, and `b1` are mandatory-to-implement per §2.1 of\n   * draft-ietf-cbor-edn-literals-26; disabling them produces a parser that\n   * no longer conforms to that recommendation. This is intended for\n   * allowlisting scenarios (see §7 Security considerations of the same\n   * draft) where an application wants explicit control over which\n   * extensions it accepts from untrusted CDN input.\n   *\n   * @example\n   * // Only accept dt/DT — everything else becomes an Unresolved (tag 999) node.\n   * import { CBOR, dt } from '@cbortech/cbor';\n   * CBOR.fromCDN(text, { builtinExtensions: [dt] });\n   */\n  builtinExtensions?: CborExtension[] | false;\n\n  /**\n   * How to handle unrecognised application-extension identifiers\n   * (§4.1 of draft-ietf-cbor-edn-literals-25).\n   *\n   * - `'cpa999'`: wrap the literal in a `CPA999` tag\n   *   (`CborUnresolvedAppExt`) instead of failing. The resulting node\n   *   round-trips through `toCDN()` back to the original notation.\n   * - `'error'`: throw `SyntaxError` for unknown prefixes.\n   * @default 'cpa999'\n   */\n  unresolvedExtension?: 'cpa999' | 'error';\n\n  /**\n   * When `true`, byte-string chunks in text string concatenation\n   * (`\"a\" + h'...'`) that are not valid UTF-8 are decoded with the Unicode\n   * replacement character (U+FFFD) instead of throwing a `SyntaxError`.\n   *\n   * The CBOR text string type (RFC 8949 §3.1) requires valid UTF-8;\n   * enabling this option produces non-conformant output and should only be\n   * used when interoperating with lenient producers.\n   *\n   * @default false\n   */\n  allowInvalidUtf8?: boolean;\n\n  /**\n   * Preserve comments found between CDN values and attach them to the AST.\n   *\n   * Comments are metadata only: they are ignored by CBOR binary encoding and\n   * JavaScript conversion. Use together with `ToCDNOptions.preserveComments`\n   * to include them when formatting back to CDN.\n   *\n   * The string values `'c-style'` and `'cdn-style'` are treated as `true`\n   * for parsing purposes; they become meaningful when passed to `toCDN()`.\n   *\n   * @default false\n   */\n  preserveComments?: boolean | 'c-style' | 'cdn-style';\n\n  /**\n   * Shorthand for `ToCDNOptions.preserveAll`, so a single option enables\n   * round-tripping through both `fromCDN()` and `toCDN()` (as\n   * `CBOR.format()` does internally). On the parse side, this only implies\n   * `preserveComments: true` (comments must be captured while parsing to be\n   * re-emittable); the other `preserve*` behaviors are always captured by\n   * the parser and only need to be turned on for `toCDN()`.\n   *\n   * @default false\n   */\n  preserveAll?: boolean;\n\n  /**\n   * Controls how CDN/EDN validity violations are handled.\n   *\n   * - `true` (default): recoverable violations call `onWarning` and then throw.\n   * - `false`: recoverable violations call `onWarning` and parsing continues\n   *   with a best-effort interpretation of the input.\n   *\n   * Hard syntax errors (e.g. unterminated strings, unexpected tokens that\n   * prevent parsing a value) always throw regardless of this setting.\n   * A trailing token after a successfully-parsed value is a recoverable\n   * violation and is therefore controlled by this flag.\n   *\n   * @default true\n   */\n  strict?: boolean;\n\n  /**\n   * Callback invoked when a CDN/EDN validity violation is detected.\n   *\n   * In strict mode (the default), this is called before the error is thrown.\n   * In non-strict mode (`strict: false`), this is called and parsing continues.\n   *\n   * If not supplied and `silent` is not `true`, violations are reported via\n   * `console.warn`.\n   */\n  onWarning?: (warning: ParseWarning) => void;\n\n  /**\n   * When `true`, suppresses the default `console.warn` output for validity\n   * violations.  An explicit `onWarning` callback is still invoked even when\n   * `silent` is `true`.\n   *\n   * @default false\n   */\n  silent?: boolean;\n\n  /**\n   * Compiled CDDL schema to validate parsed items against.\n   * Mirrors `FromCBOROptions.cddl`.\n   */\n  cddl?: CddlSchema | string;\n\n  /**\n   * Options forwarded to the CDDL validator.\n   * Mirrors `FromCBOROptions.cddlValidationOptions`.\n   */\n  cddlValidationOptions?: CddlValidateOptions;\n}\n\n/**\n * Options for parsing Concise Diagnostic Notation (CDN).\n *\n * @deprecated Use `FromCDNOptions` instead.\n */\nexport type FromEDNOptions = FromCDNOptions;\n\nexport interface FromJSOptions {\n  /**\n   * Extension plugins applied during `fromJS()`.\n   * Extensions with `fromJS()` are given first chance to convert each value.\n   */\n  extensions?: CborExtension[];\n\n  /**\n   * Override the default set of bundled application-oriented extensions.\n   * Mirrors `FromCDNOptions.builtinExtensions`. Only affects builtins that\n   * implement `fromJS()` / `parseTag()` (none of the bundled application\n   * extensions implement `fromJS()` by default — use `dt_as_Date` via\n   * `extensions` for `Date` round-tripping).\n   */\n  builtinExtensions?: CborExtension[] | false;\n\n  /**\n   * How to encode integer-valued JS `number`s.\n   * - `'int'`: encode as CborUint / CborNint\n   * - `'float'`: always encode as CborFloat\n   * @default 'int'\n   */\n  encodeIntegerAs?: 'int' | 'float';\n\n  /**\n   * How to encode `Uint8Array` values.\n   * - `'bytes'`: encode as CborByteString\n   * - `'array'`: encode as CborArray of CborUint\n   * @default 'bytes'\n   */\n  uint8ArrayAs?: 'bytes' | 'array';\n\n  /**\n   * Pre-encoding replacer function or key allowlist, applied before the\n   * JavaScript value is converted to a CBOR AST node.\n   *\n   * - Function: called for every key/value pair (including `MapEntries`\n   *   entries with non-string keys).  Return `CBOR.OMIT` to remove the entry.\n   *   When `undefinedOmits` is `true`, returning `undefined` also removes it.\n   * - Array of strings/numbers: allowlist of object keys to include.\n   *   `MapEntries` entries retain all entries; their values are recursively\n   *   filtered.\n   *\n   * Note: this option is honoured by `fromJS()` and the `CBOR.*` shortcut\n   * methods.\n   */\n  replacer?:\n    | ((this: unknown, key: unknown, value: unknown) => unknown)\n    | (string | number)[];\n\n  /**\n   * When `true`, a replacer returning `undefined` removes the entry from the\n   * output, matching `JSON.stringify` behavior.\n   * When `false` (default), only `CBOR.OMIT` removes an entry; returning\n   * `undefined` keeps the entry as CBOR `undefined` (simple 23).\n   * @default false\n   */\n  undefinedOmits?: boolean;\n\n  /**\n   * Compiled CDDL schema to validate the constructed item against, before\n   * encoding/serialization. Mirrors `FromCBOROptions.cddl`.\n   */\n  cddl?: CddlSchema | string;\n\n  /**\n   * Options forwarded to the CDDL validator.\n   * Mirrors `FromCBOROptions.cddlValidationOptions`.\n   */\n  cddlValidationOptions?: CddlValidateOptions;\n}\n\nexport interface ToCDNOptions {\n  /**\n   * Indentation for pretty-printing.\n   * - `number`: number of spaces\n   * - `string`: literal indent string (e.g. `'\\t'`)\n   * - omit for single-line output\n   *\n   * Like `JSON.stringify`, `0` and `''` are equivalent to omitting the\n   * option: the output is a single line. Single-line output is guaranteed\n   * to contain no newlines; layout-dependent options (`preserveComments`,\n   * `preserveBlankLines`, `splitCdn`, `splitNewline`, `preserveConcatenation`)\n   * are ignored.\n   */\n  indent?: number | string;\n\n  /**\n   * Master switch that turns on every `preserve*` option below at once,\n   * except the deprecated `preserveTextString` — `preserveComments`,\n   * `preserveByteString`, `preserveRawString`, `preserveConcatenation`,\n   * `preserveNumberFormat`, `preserveAppSequence`, and\n   * `preserveBlankLines` — for reformatting CDN text (e.g. on save in an\n   * editor) with minimal changes: only whitespace/indentation, plus\n   * anything an explicitly-set individual option overrides.\n   *\n   * An option explicitly set to a value (including `false`) is left as-is;\n   * `preserveAll` only fills in the ones left `undefined`. So\n   * `{ preserveAll: true, preserveNumberFormat: false }` preserves\n   * everything except number literal spelling.\n   *\n   * When parsing via `CBOR.fromCDN()` separately from `toCDN()` (rather\n   * than through `CBOR.format()`, which passes the same options to both),\n   * also pass `preserveAll` (or `preserveComments`) to `FromCDNOptions` so\n   * comments are captured in the first place — see\n   * `FromCDNOptions.preserveAll`. Bignums are unaffected by\n   * `preserveNumberFormat` even under `preserveAll`; see that option.\n   *\n   * @default false\n   */\n  preserveAll?: boolean;\n\n  /**\n   * Emit comments previously captured by `FromCDNOptions.preserveComments`.\n   *\n   * - `true`: emit comments with their original markers.\n   * - `'c-style'`: emit comments, normalising line comments to `//` and block\n   *   comments to `/* … *\\/`.\n   * - `'cdn-style'`: emit comments, normalising line comments to `#` and block\n   *   comments to `/ … /`. When a `/* … *\\/` comment's content contains `/`\n   *   (which cannot be represented inside `/ … /`), the `/* … *\\/` form is\n   *   kept as-is.\n   * - `false` / omitted: strip all comments from the output.\n   *\n   * Only effective when `indent` enables pretty-printing: single-line\n   * output strips all comments, since line comments (`#`, `//`) can only\n   * be terminated by a newline.\n   *\n   * @default false\n   */\n  preserveComments?: boolean | 'c-style' | 'cdn-style';\n\n  /**\n   * Re-emit a blank line above an array/map entry (or indefinite-length\n   * string chunk) that had one before it anywhere in the parsed CDN source,\n   * so paragraph-like groupings of entries survive a reformat. At most one\n   * blank line is ever emitted per gap, regardless of how many blank lines\n   * were originally there.\n   *\n   * Detection is based purely on entry source positions — it does not\n   * require `preserveComments` and is unaffected by whether comments are\n   * emitted.\n   *\n   * Only effective when `indent` enables pretty-printing. A container with\n   * a preserved blank line is always emitted one-entry-per-line, the same\n   * as a container with preserved comments (see `inlineLeafContainers`).\n   *\n   * @default false\n   */\n  preserveBlankLines?: boolean;\n\n  /**\n   * Re-emit byte string literals parsed from CDN using their original source\n   * text when available.\n   *\n   * This preserves the spelling and interior layout of non-concatenated\n   * `h'...'`, `b64'...'`, `b32'...'`, `h32'...'`, raw-backtick byte strings,\n   * and single-quoted byte strings — including a `h'xx...yy'`-family elided\n   * literal (§4.2), whose spelling is kept independently of\n   * `preserveConcatenation` when it has no `+` of its own (see that\n   * option). Byte strings produced by `+` concatenation are normalised as\n   * usual; combine with `preserveConcatenation` to keep both the part\n   * boundaries and each part's spelling.\n   *\n   * A comment inside the literal is stripped unless `preserveComments` is\n   * also set — `preserveByteString` alone preserves everything about the\n   * literal's spelling *except* its comments, the same as an unpreserved\n   * literal (re-derived from the decoded value) never has comments either.\n   *\n   * When enabled, this takes precedence over `bstrEncoding` and `sqstr` for\n   * byte strings that carry original EDN source text.\n   *\n   * In single-line output (no `indent`), an original spelling that spans\n   * multiple lines — after any comment is stripped — falls back to normal\n   * serialization; single-line spellings are kept.\n   *\n   * @default false\n   */\n  preserveByteString?: boolean;\n\n  /**\n   * Re-emit text strings written as raw backtick literals (`` `...` ``,\n   * ``` ``...`` ```, …) using their original source text instead of\n   * converting them to double-quoted form.\n   *\n   * Applies to non-concatenated raw string literals; combine with\n   * `preserveConcatenation` to also keep the spelling of raw string parts\n   * inside a `+` chain. Preserved raw strings are emitted verbatim: they are\n   * never re-escaped, re-indented, or split by `splitCdn` / `splitNewline`.\n   *\n   * Raw byte string forms (e.g. `` h`...` ``) are covered by\n   * `preserveByteString`, not this option.\n   *\n   * In single-line output (no `indent`), a spelling that spans multiple\n   * lines falls back to normal escaping; single-line spellings are kept.\n   *\n   * @default false\n   */\n  preserveRawString?: boolean;\n\n  /**\n   * Re-emit double-quoted text strings (`\"...\"`) using their original CDN\n   * source spelling — escape sequences (`é` vs. the literal character),\n   * quoting choices, etc. — instead of re-escaping them from the decoded\n   * string value.\n   *\n   * Applies to non-concatenated double-quoted literals only; a string\n   * reached via `+` concatenation is normalised as usual regardless of this\n   * option. Preserved strings are emitted verbatim: they are never\n   * re-indented or split by `splitCdn` / `splitNewline`.\n   *\n   * Raw backtick literals (`` `...` ``) are covered by `preserveRawString`,\n   * not this option.\n   *\n   * In single-line output (no `indent`), a spelling that spans multiple\n   * lines falls back to normal escaping; single-line spellings are kept.\n   *\n   * @deprecated Verbatim spelling and `splitCdn` / `splitNewline` reflow\n   *   are mutually exclusive for a given literal — enabling this option\n   *   silently defeats both for any non-concatenated double-quoted string.\n   *   It still works when set explicitly, but no longer participates in\n   *   `preserveAll` and has been removed from the playground's preserve\n   *   options.\n   *\n   * @default false\n   */\n  preserveTextString?: boolean;\n\n  /**\n   * Re-emit integer and floating-point literals using their original CDN\n   * source spelling — base (`0xff` / `0o377` / `0b101` / decimal), digit\n   * spelling, decimal point / exponent form, and encoding-indicator suffix\n   * (e.g. `1.5_1`) — instead of normalising them via `intFormat` /\n   * `floatFormat` and recomputed encoding indicators.\n   *\n   * Takes precedence over `intFormat` and `floatFormat` for literals parsed\n   * from CDN text. Values that did not originate from CDN text (e.g. built\n   * via `CBOR.from()` or decoded from CBOR bytes) always fall back to normal\n   * formatting, since there is no original spelling to preserve. Bignums\n   * (integers outside the uint64/int64 range) are unaffected and always\n   * render as plain decimal.\n   *\n   * Combine with `preserveByteString`, `preserveRawString`,\n   * `preserveConcatenation`, and `preserveComments` to reformat CDN text\n   * (e.g. whitespace/indentation only) with minimal changes to the rest of\n   * the source.\n   *\n   * @default false\n   */\n  preserveNumberFormat?: boolean;\n\n  /**\n   * Whether to emit commas between array/map elements.\n   * - `'comma'`: emit commas (`[1, 2, 3]`)\n   * - `'none'`: omit commas, use spaces only (`[1 2 3]`)\n   * - `'trailing'`: emit commas including a trailing comma after the last element\n   * @default 'comma'\n   */\n  commas?: 'comma' | 'none' | 'trailing';\n\n  /**\n   * Fallback binary encoding for byte string literals when sqstr is not applicable.\n   * - `'hex'`: `h'...'`\n   * - `'base64'`: `b64'...'`\n   * - `'base64url'`: `b64'...'` (base64url alphabet)\n   * @default 'hex'\n   */\n  bstrEncoding?: 'hex' | 'base64' | 'base64url';\n\n  /**\n   * Whether to prefer single-quoted string form (`sqstr`) for byte strings.\n   * - `'printable-string'`: emit `'...'` when the bytes are valid UTF-8 and\n   *   contain no control characters; fall back to `bstrEncoding` otherwise.\n   * - `'string'`: emit `'...'` when the bytes are valid UTF-8;\n   *   fall back to `bstrEncoding` otherwise.\n   * - `'none'`: never emit sqstr; always use `bstrEncoding`.\n   * @default 'printable-string'\n   */\n  sqstr?: 'printable-string' | 'string' | 'none';\n\n  /**\n   * Whether to use application-string / app-sequence notation for built-in\n   * extensions (e.g. `dt'...'`, `DT'...'`, `ip'...'`, `IP'...'`).\n   * - `true`: emit extension notation (`DT'2023-01-01T12:00:00Z'`)\n   * - `false`: emit raw CBOR notation (`1(-14159024)`, `52(h'c000022a')`)\n   * @default true\n   */\n  appStrings?: boolean;\n\n  /**\n   * For built-in extensions that support application-string notation\n   * (`prefix'...'` or `` prefix`...` ``), application-sequence notation\n   * (`prefix<<...>>`), and/or a raw tag literal (`N(...)`), re-emit a value\n   * using its exact original spelling instead of normalizing it to the\n   * regenerated `prefix'...'` form.\n   *\n   * By default, an extension like `dt`/`DT` or `ip`/`IP` regenerates its\n   * notation from the resolved value on every call — so\n   * `` DT`1969-07-21T02:56:16Z` ``, `DT<<'1969-07-21T02:56:16Z'>>`, and even\n   * the raw tag form `1(1749772800)` all become\n   * `DT'2025-06-13T00:00:00Z'`-style `prefix'...'` notation, even though all\n   * of these denote the same value. `preserveAppSequence` keeps the\n   * original spelling instead — whichever quoting (`'...'` vs `` `...` ``),\n   * bracketing (`<<...>>`), or raw tag form was used. Has no effect when\n   * `appStrings` is `false` (raw tag notation is used either way regardless\n   * of the original spelling), or on values not parsed from one of these\n   * forms.\n   *\n   * In single-line output (no `indent`), a spelling that spans multiple\n   * lines falls back to normal (regenerated) notation; single-line\n   * spellings are kept.\n   *\n   * An explicit `preserveComments` setting is still applied to comments\n   * inside a preserved application-sequence spelling: marker styles are\n   * normalised without changing the notation family, and `false` removes\n   * the comments while retaining the surrounding source spelling.\n   *\n   * @default false\n   */\n  preserveAppSequence?: boolean;\n\n  /**\n   * Numeric format for integer values in CDN output.\n   * - `'decimal'`: standard decimal notation (e.g. `42`, `-14159024`)\n   * - `'hex'`: hexadecimal notation (e.g. `0x2a`, `-0xd83130`)\n   * - `'octal'`: octal notation (e.g. `0o52`, `-0o67061560`)\n   * - `'binary'`: binary notation (e.g. `0b101010`, `-0b110110000011000100110000`)\n   * @default 'decimal'\n   */\n  intFormat?: 'decimal' | 'hex' | 'octal' | 'binary';\n\n  /**\n   * Numeric format for floating-point values in CDN output.\n   * - `'decimal'`: standard decimal notation (e.g. `1.5`, `145544.0_3`)\n   * - `'hex'`: C99-style hex float notation (e.g. `0x1.8p+0`, `0x1.1c54p+17_3`)\n   * @default 'decimal'\n   */\n  floatFormat?: 'decimal' | 'hex';\n\n  /**\n   * Split long text strings using CDN string concatenation syntax (`\"a\" + \"b\"`).\n   * Only effective when `indent` enables pretty-printing.\n   *\n   * - `'newline'`: split at newline characters\n   * - `'cdn'`: split according to CDN structure when the string content\n   *                is parseable as CDN (JSON superset)\n   * - `'cboredn'`: deprecated alias for `'cdn'`\n   *\n   * When both are specified, CDN structure split points are combined with\n   * newline split points.\n   *\n   * @deprecated Use `splitCdn` / `splitNewline` instead. When one of those\n   *   is specified, it takes precedence over the corresponding array entry.\n   */\n  textStringFormat?: TextStringFormat[];\n\n  /**\n   * Format text strings whose content is parseable as CDN (a JSON superset)\n   * by splitting them with CDN string concatenation (`\"{\" + \"1:2\" + \"}\"`)\n   * and structure-aware indentation, the same way the surrounding CDN is\n   * formatted. Only effective when `indent` is specified.\n   *\n   * When the string content parses as CDN, this takes precedence over\n   * `preserveConcatenation`; when it does not, the original concatenation\n   * is preserved as usual.\n   *\n   * Replaces the deprecated `textStringFormat: ['cdn']`.\n   *\n   * @default false\n   */\n  splitCdn?: boolean;\n\n  /**\n   * Split text strings at newline characters using CDN string concatenation\n   * (`\"line1\\n\" + \"line2\"`). Only effective when `indent` is specified.\n   *\n   * Combines with `preserveConcatenation`: preserved concatenation parts\n   * are further split at the newline characters they contain.\n   *\n   * Replaces the deprecated `textStringFormat: ['newline']`.\n   *\n   * @default false\n   */\n  splitNewline?: boolean;\n\n  /**\n   * Preserve `+` string concatenation from the parsed CDN source.\n   *\n   * When a text string or byte string was parsed from a CDN concatenation\n   * chain (e.g. `\"a\" + \"b\"` or `h'01' + h'02'`), re-emit it as a\n   * concatenation with the original part boundaries instead of joining the\n   * parts into a single literal. Each part is re-serialized with the normal\n   * rules (`bstrEncoding` / `sqstr` for byte strings); combine with\n   * `preserveByteString` to also keep the original spelling of byte string\n   * parts.\n   *\n   * Interaction with the split options: `splitCdn` takes precedence for\n   * text strings whose content parses as CDN, while `splitNewline` combines\n   * with this option by further splitting the preserved parts at newline\n   * characters. Has no effect on values that did not originate from a CDN\n   * concatenation, and only takes effect when `indent` enables\n   * pretty-printing (single-line output joins the parts into one literal).\n   *\n   * Also applies within an elision (`...`, §4.2 of\n   * draft-ietf-cbor-edn-literals-25): a `+`-joined fragment on either side of\n   * an ellipsis keeps its own part boundaries too (e.g. `'test' +\n   * h'1234...abcd' + ...` stays exactly as written instead of merging\n   * `'test'` into the byte fragment before it), and byte-string elision\n   * keeps the `h'xx' + ... + h'yy'` spelling instead of the default compact\n   * `h'xx...yy'` literal. Unlike the text/byte-string case above, this\n   * applies regardless of `indent`, and the parts stay on one line even\n   * under `indent` (elision is always single-line): a `+` boundary inside an\n   * ellipsis is never a lossless merge — the elided middle can't be \"joined\n   * in\" — so there's no indent-dependent fallback to prefer, and no reason\n   * to reflow it.\n   *\n   * @default false\n   */\n  preserveConcatenation?: boolean;\n\n  /**\n   * When pretty-printing with `indent`, keep a container on a single line\n   * when none of its entries contains an array or map (even wrapped in a\n   * tag) and every entry serializes without a line break (e.g. `[1, 2, 3]`,\n   * `{\"a\": 1}`, `(_ \"a\", \"b\")`). Nested leaf containers still collapse\n   * individually: `[[1, 2], [3, 4]]` renders with one inner array per line.\n   *\n   * `<<...>>` (CBOR Sequence Literal / embedded CBOR) is the one exception:\n   * since it's a flat sequence of encoded items rather than a\n   * nested-structure display, an entry that is itself an array/map still\n   * inlines there as long as its own rendering fits on one line — e.g.\n   * `<<{1: -7}>>` stays on one line, even though `[{1: -7}]` would not.\n   *\n   * Containers with preserved comments are always emitted in multi-line\n   * form. Has no effect when `indent` is omitted.\n   *\n   * @default false\n   */\n  inlineLeafContainers?: boolean;\n\n  /**\n   * Control whether CBOR encoding-width indicators (`_N`) are appended to CDN output.\n   *\n   * - `'always'`: always emit the encoding indicator, even for canonical encodings\n   *   (e.g. `1_i`, `\"hello\"_i`, `[_i 1, 2]`)\n   * - `'auto'`: emit indicators only when the CBOR encoding is non-canonical —\n   *   i.e. more bytes were used than necessary (e.g. `1_3` for a uint encoded with 8 bytes)\n   * - `'never'`: never emit encoding indicators\n   *\n   * @default 'auto'\n   */\n  encodingIndicators?: 'always' | 'auto' | 'never';\n}\n\nexport type TextStringFormat = 'newline' | 'cdn' | DeprecatedTextStringFormat;\n\n/** @deprecated Use `'cdn'` instead. */\nexport type DeprecatedTextStringFormat = 'cboredn';\n\n/**\n * Options for serializing Concise Diagnostic Notation (CDN).\n *\n * @deprecated Use `ToCDNOptions` instead.\n */\nexport type ToEDNOptions = ToCDNOptions;\n\nexport interface CborComment {\n  kind: 'line' | 'block';\n  marker: '#' | '//' | '/*' | '/';\n  text: string;\n  start: number;\n  end: number;\n  line: number;\n  col: number;\n  /**\n   * `true` when this is a `leading` comment that ends on the same source\n   * line as the node it's attached to — e.g. `/ protected / << ... >>` in an\n   * RFC 9052-style annotated array, as opposed to a comment on its own line\n   * above the value. `toCDN()` renders these as an inline prefix on the\n   * value's own line instead of a separate line above it. `undefined` for\n   * `trailing`/`dangling` comments, where it doesn't apply.\n   */\n  sameLine?: boolean;\n}\n\nexport interface CborComments {\n  leading?: CborComment[];\n  trailing?: CborComment[];\n  dangling?: CborComment[];\n}\n\n/**\n * Options for `CBOR.validate()`.\n */\nexport interface ValidateOptions {\n  /**\n   * Input format.\n   * - `'cbor'`: binary CBOR, decoded as a CBOR Sequence (RFC 8742).\n   * - `'cdn'`: CDN text, parsed as a CDN Sequence.\n   * - `'hex'`: annotated hex dump text, decoded as a CBOR Sequence.\n   * @default 'cbor'\n   */\n  type?: 'cbor' | 'cdn' | 'hex';\n\n  /**\n   * Extension plugins used while decoding/parsing.\n   * Mirrors `FromCBOROptions.extensions` / `FromCDNOptions.extensions`.\n   */\n  extensions?: CborExtension[];\n\n  /**\n   * Override the default set of bundled application-oriented extensions.\n   * Mirrors `FromCBOROptions.builtinExtensions`.\n   */\n  builtinExtensions?: CborExtension[] | false;\n\n  /**\n   * How to handle unrecognised application-extension identifiers.\n   * Only applies when `type` is `'cdn'`; mirrors `FromCDNOptions.unresolvedExtension`.\n   * @default 'cpa999'\n   */\n  unresolvedExtension?: 'cpa999' | 'error';\n\n  /**\n   * CDDL schema to validate each decoded/parsed item against: either a\n   * compiled schema (`CDDL.compile()` from `@cbortech/cbor/cddl`) or CDDL\n   * source text (compiled on first use and cached; mirrors\n   * `FromCBOROptions.cddl`).\n   *\n   * Unlike the throwing entry points, `CBOR.validate()` does not throw on a\n   * mismatch: failures are collected into `ValidateResult.cddlErrors` (and\n   * validator observations into `ValidateResult.cddlWarnings`), and any\n   * mismatch makes `valid` `false`. Each item of a sequence is validated\n   * individually against the schema's root rule by default (or\n   * `cddlValidationOptions.rule`, if set). Note that invalid CDDL source\n   * text itself still throws (`CddlSyntaxError` / `CddlSemanticError`): the\n   * schema is part of the call, not the data being validated.\n   */\n  cddl?: CddlSchema | string;\n\n  /**\n   * Options forwarded to the CDDL validator.\n   * Mirrors `FromCBOROptions.cddlValidationOptions`.\n   */\n  cddlValidationOptions?: CddlValidateOptions;\n}\n\n/**\n * Result of `CBOR.validate()`.\n */\nexport interface ValidateResult {\n  /**\n   * `true` when every item decoded/parsed without error and without any\n   * warnings. `false` when the input was malformed (see `error`) or\n   * well-formed but in violation of a validity constraint (see `warnings`).\n   */\n  valid: boolean;\n\n  /** Number of items successfully decoded/parsed before any error. */\n  count: number;\n\n  /**\n   * Validity violations encountered while decoding/parsing in non-strict\n   * mode (recoverable — decoding continued after each one). Excludes\n   * informational hints (see `hints`) and the fatal CDN warning that\n   * `error` is built from, if any.\n   */\n  warnings: (DecodeWarning | ParseWarning)[];\n\n  /**\n   * Informational hints (`ParseWarning.hint`) encountered while parsing,\n   * e.g. an app-string prefix that matches a known optional extension which\n   * isn't registered. Hints never affect `valid`; they are collected here so\n   * tooling can still surface them.\n   */\n  hints: ParseWarning[];\n\n  /**\n   * Set when decoding/parsing failed outright: either it threw (e.g.\n   * truncated CBOR data), or — for CDN input — `fromCDNSeq()` abandoned the\n   * rest of the sequence after a hard syntax error (reported internally as a\n   * `fatal` warning, which `validate()` promotes to `error` rather than\n   * including in `warnings`). For a CDN syntax error this is the original\n   * `CdnSyntaxError`, position fields intact.\n   */\n  error?: Error;\n\n  /**\n   * CDDL validation failures, collected per decoded item. Only present when\n   * `ValidateOptions.cddl` was supplied (empty array when every item\n   * matched). Any entry makes `valid` `false`.\n   */\n  cddlErrors?: CddlValidationError[];\n\n  /**\n   * Non-fatal CDDL validator observations (e.g. unsupported control\n   * operators whose constraints were skipped). Only present when\n   * `ValidateOptions.cddl` was supplied. Never affects `valid`.\n   */\n  cddlWarnings?: CddlValidationWarning[];\n}\n\n/** `fromCBORSeq()` の options（`offset`/`allowTrailing` はジェネレータが管理するため除外）。 */\nexport type FromCBORSeqOptions = Omit<\n  FromCBOROptions,\n  'offset' | 'allowTrailing'\n>;\n\n/** `fromCDNSeq()` の options（`offset`/`allowTrailing` はジェネレータが管理するため除外）。 */\nexport type FromCDNSeqOptions = Omit<\n  FromCDNOptions,\n  'offset' | 'allowTrailing'\n>;\n\n/**\n * Combined options for the `CBOR` constructor.\n *\n * These defaults are applied to every subsequent method call on the instance.\n * Per-call options always take precedence over these defaults.\n *\n * Note: `encodeIntegerAs` (from {@link FromJSOptions}) and `integerAs` (from\n * {@link ToJSOptions}) are distinct fields and do not conflict.\n */\nexport type CBOROptions = FromCDNOptions &\n  FromJSOptions &\n  ToCBOROptions &\n  ToCDNOptions &\n  ToJSOptions &\n  ToHexDumpOptions;\n","/**\n * Wrapper for unrecognised CBOR simple values (0–255, excluding false/true/\n * null/undefined). Returned by CborSimple.toJS() so that fromJS() can\n * reconstruct the original CborSimple node and preserve the round-trip.\n *\n * Also serves as a namespace for simple-value utilities.\n *\n * @example\n * const v = CBOR.fromCDN('simple(19)').toJS();\n * Simple.is(v);    // true\n * Simple.get(v);   // 19\n *\n * const node = CBOR.fromJS(new Simple(19));\n * node.toCDN();    // \"simple(19)\"\n */\nexport class Simple {\n  readonly value: number;\n\n  constructor(value: number) {\n    if (!Number.isInteger(value) || value < 0 || value > 255)\n      throw new RangeError('Simple value must be an integer in 0–255');\n    this.value = value;\n  }\n\n  valueOf(): number {\n    return this.value;\n  }\n\n  toJSON(): never {\n    throw new TypeError(`simple(${this.value}) cannot be serialized to JSON`);\n  }\n\n  /** Return true if value is a Simple instance. */\n  static is(value: unknown): value is Simple {\n    return value instanceof Simple;\n  }\n\n  /** Return the simple number if value is a Simple instance, otherwise undefined. */\n  static get(value: unknown): number | undefined {\n    return value instanceof Simple ? value.value : undefined;\n  }\n}\n","/**\n * Float16 (IEEE 754 binary16) encode/decode utilities.\n *\n * Uses native DataView.getFloat16 / setFloat16 when both are available,\n * and falls back to a manual bit-manipulation implementation otherwise.\n *\n * binary16 format:\n *   bit 15    : sign\n *   bits 14-10: exponent (5 bits, bias = 15)\n *   bits  9- 0: mantissa (10 bits)\n */\n\nexport const hasNativeFloat16 =\n  'getFloat16' in DataView.prototype && 'setFloat16' in DataView.prototype;\n\n// Reusable 8-byte buffer for float64 bit extraction (avoids per-call allocation)\nconst _buf8 = new ArrayBuffer(8);\nconst _dv8 = new DataView(_buf8);\n\n/**\n * float64 → float16 bit pattern (16-bit unsigned integer).\n *\n * Operates directly on float64 bits to avoid double-rounding artifacts that\n * arise from a float64 → float32 → float16 two-step conversion.\n * Implements IEEE 754 round-to-nearest-ties-to-even (RN-TE).\n *\n * Exported for testing (manual vs native consistency checks).\n */\nexport function float64ToFloat16Bits(value: number): number {\n  // Store the float64 in big-endian order so the bit layout is predictable\n  _dv8.setFloat64(0, value, false);\n  const hi = _dv8.getUint32(0, false); // bits 63-32 of IEEE 754 binary64\n  const lo = _dv8.getUint32(4, false); // bits 31-0\n\n  const sign = (hi >>> 31) & 1;\n  const exp64 = (hi >>> 20) & 0x7ff; // 11-bit exponent, bias 1023\n  const mantHi = hi & 0x000f_ffff; // top 20 bits of the 52-bit mantissa\n  // lo  = lower 32 bits of the mantissa\n\n  // ── Infinity / NaN ──────────────────────────────────────────────────────────\n  if (exp64 === 0x7ff) {\n    if (mantHi === 0 && lo === 0) return (sign << 15) | 0x7c00; // ±Infinity\n    // NaN: carry top 10 mantissa bits; guarantee at least one bit is set\n    const f16mant = (mantHi >> 10) | (lo !== 0 ? 1 : 0) || 1;\n    return (sign << 15) | 0x7c00 | (f16mant & 0x3ff);\n  }\n\n  // Rebias: float64 exponent bias 1023 → float16 bias 15\n  const f16Exp = exp64 - 1023 + 15;\n\n  // ── Overflow → ±Infinity ────────────────────────────────────────────────────\n  if (f16Exp >= 31) return (sign << 15) | 0x7c00;\n\n  let f16mant: number;\n  let roundBit: number;\n  let sticky: boolean;\n\n  if (f16Exp <= 0) {\n    // ── Underflow ──────────────────────────────────────────────────────────────\n    if (f16Exp < -10) return sign << 15; // → ±0\n\n    // ── Denormal ───────────────────────────────────────────────────────────────\n    // Reconstruct the 53-bit significand's top 21 bits: [implicit 1][mantHi 20-bit]\n    const top21 = (1 << 20) | mantHi;\n\n    // Right-shift amount to align the significand for a float16 denormal:\n    //   f16mant = round(top53 / 2^(43 - f16Exp))\n    // We approximate top53 ≈ top21 × 2^32 (low bits from `lo` affect only rounding).\n    const s = 11 - f16Exp; // s ∈ [11, 21]\n\n    if (s <= 20) {\n      f16mant = (top21 >> s) & 0x3ff;\n      roundBit = (top21 >> (s - 1)) & 1;\n      sticky = (top21 & ((1 << (s - 1)) - 1)) !== 0 || lo !== 0;\n    } else {\n      // s = 21: the implicit-1 bit becomes the round bit; truncated result is 0\n      f16mant = 0;\n      roundBit = 1; // implicit 1 is always present\n      sticky = mantHi !== 0 || lo !== 0;\n    }\n  } else {\n    // ── Normal ─────────────────────────────────────────────────────────────────\n    // Take the top 10 bits of the 52-bit mantissa; round using the next bits.\n    f16mant = mantHi >> 10;\n    roundBit = (mantHi >> 9) & 1;\n    sticky = (mantHi & 0x1ff) !== 0 || lo !== 0;\n  }\n\n  // ── Round-to-nearest-ties-to-even (RN-TE) ───────────────────────────────────\n  if (roundBit !== 0 && (sticky || (f16mant & 1) !== 0)) {\n    f16mant++;\n  }\n\n  // ── Mantissa overflow: carry into exponent ───────────────────────────────────\n  if (f16mant >= 1024) {\n    // Denormal rounds up to the smallest normal (exp = 1), or normal exponent increments\n    const newExp = f16Exp <= 0 ? 1 : f16Exp + 1;\n    if (newExp >= 31) return (sign << 15) | 0x7c00; // overflow to Infinity\n    return (sign << 15) | (newExp << 10); // mant = 0\n  }\n\n  const outExp = f16Exp <= 0 ? 0 : f16Exp;\n  return (sign << 15) | (outExp << 10) | f16mant;\n}\n\n/**\n * float16 bit pattern → float64.\n * Exported for testing purposes.\n */\nexport function float16BitsToFloat64(bits: number): number {\n  const sign = (bits >>> 15) & 1;\n  const exp = (bits >>> 10) & 0x1f;\n  const mant = bits & 0x3ff;\n\n  if (exp === 0x1f) {\n    return mant === 0 ? (sign ? -Infinity : Infinity) : NaN;\n  }\n  if (exp === 0) {\n    if (mant === 0) return sign ? -0 : 0;\n    // Denormal: (-1)^sign × 2^(-14) × (mant / 1024)\n    return (sign ? -1 : 1) * 2 ** -14 * (mant / 1024);\n  }\n  // Normal: (-1)^sign × 2^(exp-15) × (1 + mant/1024)\n  return (sign ? -1 : 1) * 2 ** (exp - 15) * (1 + mant / 1024);\n}\n\n/**\n * Write a float16 value at the given offset in a DataView.\n */\ntype WriteFloat16 = (\n  view: DataView,\n  offset: number,\n  value: number,\n  littleEndian: boolean\n) => void;\n\n/**\n * Read a float16 value from the given offset in a DataView, returned as float64.\n */\ntype ReadFloat16 = (\n  view: DataView,\n  offset: number,\n  littleEndian: boolean\n) => number;\n\nconst writeFloat16Native: WriteFloat16 = (\n  view,\n  offset,\n  value,\n  littleEndian\n) => {\n  view.setFloat16(offset, value, littleEndian);\n};\n\nconst writeFloat16Fallback: WriteFloat16 = (\n  view,\n  offset,\n  value,\n  littleEndian\n) => {\n  view.setUint16(offset, float64ToFloat16Bits(value), littleEndian);\n};\n\nconst readFloat16Native: ReadFloat16 = (view, offset, littleEndian) => {\n  return view.getFloat16(offset, littleEndian);\n};\n\nconst readFloat16Fallback: ReadFloat16 = (view, offset, littleEndian) => {\n  return float16BitsToFloat64(view.getUint16(offset, littleEndian));\n};\n\n// Dispatch between native and fallback once at module initialization time.\nexport const writeFloat16: WriteFloat16 = hasNativeFloat16\n  ? writeFloat16Native\n  : writeFloat16Fallback;\n\nexport const readFloat16: ReadFloat16 = hasNativeFloat16\n  ? readFloat16Native\n  : readFloat16Fallback;\n","import {\n  float64ToFloat16Bits,\n  float16BitsToFloat64,\n  writeFloat16 as writeFloat16ToView,\n} from '../utils/float16';\nimport type { FloatPrecision } from '../ast/CborFloat';\nimport { AI_1BYTE, AI_2BYTE, AI_4BYTE, AI_8BYTE } from './constants';\n\n// ─── Encoding width ───────────────────────────────────────────────────────────\n\n/**\n * EDN encoding indicator, mapping to a specific CBOR AI encoding:\n *   'i' → ai 0–23  (argument in initial byte, value must be 0–23)\n *   0   → AI 24    (1-byte argument, value must be 0–0xFF)\n *   1   → AI 25    (2-byte argument, value must be 0–0xFFFF)\n *   2   → AI 26    (4-byte argument, value must be 0–0xFFFFFFFF)\n *   3   → AI 27    (8-byte argument, value must be 0–0xFFFFFFFFFFFFFFFF)\n */\nexport type EncodingWidth = 'i' | 0 | 1 | 2 | 3;\n\n// ─── Output writer ────────────────────────────────────────────────────────────\n\n/** Scratch space for float conversions (single-threaded use only). */\nconst SCRATCH = new DataView(new ArrayBuffer(8));\nconst SCRATCH_BYTES = new Uint8Array(SCRATCH.buffer);\n\n/** Shared encoder — constructing TextEncoder per string is needlessly slow. */\nconst textEncoder = new TextEncoder();\nconst hasEncodeInto = typeof textEncoder.encodeInto === 'function';\n\n/** CBOR head size in bytes for an auto-width argument `n`. */\nfunction headSizeFor(n: number): number {\n  if (n <= 23) return 1;\n  if (n <= 0xff) return 2;\n  if (n <= 0xffff) return 3;\n  if (n <= 0xffff_ffff) return 5;\n  return 9;\n}\n\n/** CBOR head size in bytes for an explicit encoding width. */\nfunction headSizeForWidth(ew: EncodingWidth): number {\n  return ew === 'i' ? 1 : [2, 3, 5, 9][ew];\n}\n\n/**\n * Growable byte buffer used by the CBOR encoder.\n *\n * AST nodes write themselves into a single shared writer via `_encodeTo`,\n * so an encode pass performs one buffer copy at the end instead of\n * re-copying every child's bytes at each nesting level.\n *\n * @internal\n */\nexport class CborWriter {\n  private buf: Uint8Array;\n  private len = 0;\n\n  constructor(initialCapacity = 256) {\n    this.buf = new Uint8Array(initialCapacity);\n  }\n\n  private _ensure(extra: number): void {\n    const needed = this.len + extra;\n    if (needed <= this.buf.length) return;\n    let capacity = this.buf.length * 2;\n    while (capacity < needed) capacity *= 2;\n    const grown = new Uint8Array(capacity);\n    grown.set(this.buf);\n    this.buf = grown;\n  }\n\n  writeByte(b: number): void {\n    this._ensure(1);\n    this.buf[this.len++] = b;\n  }\n\n  writeBytes(bytes: Uint8Array): void {\n    this._ensure(bytes.length);\n    this.buf.set(bytes, this.len);\n    this.len += bytes.length;\n  }\n\n  writeUint16(value: number): void {\n    this._ensure(2);\n    const b = this.buf;\n    b[this.len++] = (value >>> 8) & 0xff;\n    b[this.len++] = value & 0xff;\n  }\n\n  writeUint32(value: number): void {\n    this._ensure(4);\n    const b = this.buf;\n    b[this.len++] = (value >>> 24) & 0xff;\n    b[this.len++] = (value >>> 16) & 0xff;\n    b[this.len++] = (value >>> 8) & 0xff;\n    b[this.len++] = value & 0xff;\n  }\n\n  writeBigUint64(value: bigint): void {\n    SCRATCH.setBigUint64(0, value, false);\n    this._ensure(8);\n    this.buf.set(SCRATCH_BYTES, this.len);\n    this.len += 8;\n  }\n\n  writeFloat16(value: number): void {\n    writeFloat16ToView(SCRATCH, 0, value, false);\n    this._ensure(2);\n    const b = this.buf;\n    b[this.len++] = SCRATCH_BYTES[0];\n    b[this.len++] = SCRATCH_BYTES[1];\n  }\n\n  writeFloat32(value: number): void {\n    SCRATCH.setFloat32(0, value, false);\n    this._ensure(4);\n    const b = this.buf;\n    b[this.len++] = SCRATCH_BYTES[0];\n    b[this.len++] = SCRATCH_BYTES[1];\n    b[this.len++] = SCRATCH_BYTES[2];\n    b[this.len++] = SCRATCH_BYTES[3];\n  }\n\n  writeFloat64(value: number): void {\n    SCRATCH.setFloat64(0, value, false);\n    this._ensure(8);\n    this.buf.set(SCRATCH_BYTES, this.len);\n    this.len += 8;\n  }\n\n  /**\n   * Write a definite-length string head + UTF-8 body in one pass.\n   *\n   * The body is encoded directly into this writer's buffer with\n   * TextEncoder.encodeInto(), avoiding the temporary Uint8Array that\n   * TextEncoder.encode() allocates for every string.  The head position is\n   * predicted from the UTF-16 length (a lower bound on the UTF-8 length);\n   * when multi-byte characters push the byte count across a head-width\n   * boundary the body is shifted up with copyWithin (rare in practice).\n   */\n  writeTextString(\n    mt: number,\n    value: string,\n    encodingWidth?: EncodingWidth\n  ): void {\n    if (!hasEncodeInto) {\n      // Environments without encodeInto: one temporary array, as before.\n      const encoded = textEncoder.encode(value);\n      writeHeadTo(this, mt, encoded.length, encodingWidth);\n      this.writeBytes(encoded);\n      return;\n    }\n    const predictedHead =\n      encodingWidth === undefined\n        ? headSizeFor(value.length)\n        : headSizeForWidth(encodingWidth);\n    // Worst case: 3 UTF-8 bytes per UTF-16 code unit, plus the largest head.\n    this._ensure(9 + 3 * value.length);\n    const { written } = textEncoder.encodeInto(\n      value,\n      this.buf.subarray(this.len + predictedHead)\n    );\n    // The UTF-8 length is never smaller than the UTF-16 length, so the head\n    // can only grow; the _ensure above already covers the largest head.\n    const head =\n      encodingWidth === undefined ? headSizeFor(written) : predictedHead;\n    if (head !== predictedHead) {\n      this.buf.copyWithin(\n        this.len + head,\n        this.len + predictedHead,\n        this.len + predictedHead + written\n      );\n    }\n    // For an explicit encodingWidth too small for `written` this throws\n    // RangeError before writing anything; this.len is untouched in that case.\n    writeHeadTo(this, mt, written, encodingWidth);\n    this.len += written;\n  }\n\n  /** Copy of the bytes written so far. */\n  finish(): Uint8Array {\n    return this.buf.slice(0, this.len);\n  }\n}\n\n// ─── Header encoding ──────────────────────────────────────────────────────────\n\nconst MAX_FOR_WIDTH = [\n  0xffn,\n  0xffffn,\n  0xffff_ffffn,\n  0xffff_ffff_ffff_ffffn,\n] as const;\n\n/** Maximum CBOR argument value representable with the given encoding width. */\nexport function maxForEncodingWidth(ew: EncodingWidth): bigint {\n  return ew === 'i' ? 23n : MAX_FOR_WIDTH[ew];\n}\n\n/**\n * Write a CBOR initial byte + argument into `w`.\n *\n * When `encodingWidth` is provided the argument is always written using that\n * many additional bytes (AI = 24 + encodingWidth), even if the value would fit\n * in fewer bytes.  Without it the smallest valid encoding is chosen.\n *\n * `value` may be a number (common for lengths and counts — avoids a BigInt\n * allocation per head) or a bigint (required for full uint64 range).\n */\nexport function writeHeadTo(\n  w: CborWriter,\n  mt: number,\n  value: number | bigint,\n  encodingWidth?: EncodingWidth\n): void {\n  // Fast path: auto-width number argument below 2^32\n  if (\n    encodingWidth === undefined &&\n    typeof value === 'number' &&\n    value < 0x1_0000_0000\n  ) {\n    if (value <= 23) {\n      w.writeByte((mt << 5) | value);\n    } else if (value <= 0xff) {\n      w.writeByte((mt << 5) | AI_1BYTE);\n      w.writeByte(value);\n    } else if (value <= 0xffff) {\n      w.writeByte((mt << 5) | AI_2BYTE);\n      w.writeUint16(value);\n    } else {\n      w.writeByte((mt << 5) | AI_4BYTE);\n      w.writeUint32(value);\n    }\n    return;\n  }\n\n  const v = typeof value === 'number' ? BigInt(value) : value;\n  if (encodingWidth !== undefined) {\n    // Immediate encoding: value must fit in the lower 5 bits of the initial byte\n    if (encodingWidth === 'i') {\n      if (v > 23n)\n        throw new RangeError(\n          `value ${v} does not fit in immediate encoding _i (max 23)`\n        );\n      w.writeByte((mt << 5) | Number(v));\n      return;\n    }\n    if (v > MAX_FOR_WIDTH[encodingWidth]) {\n      throw new RangeError(\n        `value ${v} does not fit in encodingWidth _${encodingWidth} (max ${MAX_FOR_WIDTH[encodingWidth]})`\n      );\n    }\n    const ai = AI_1BYTE + encodingWidth; // 24, 25, 26, or 27\n    w.writeByte((mt << 5) | ai);\n    if (ai === AI_1BYTE) w.writeByte(Number(v));\n    else if (ai === AI_2BYTE) w.writeUint16(Number(v));\n    else if (ai === AI_4BYTE) w.writeUint32(Number(v));\n    else w.writeBigUint64(v);\n    return;\n  }\n  if (v <= 23n) {\n    w.writeByte((mt << 5) | Number(v));\n  } else if (v <= 0xffn) {\n    w.writeByte((mt << 5) | AI_1BYTE);\n    w.writeByte(Number(v));\n  } else if (v <= 0xffffn) {\n    w.writeByte((mt << 5) | AI_2BYTE);\n    w.writeUint16(Number(v));\n  } else if (v <= 0xffff_ffffn) {\n    w.writeByte((mt << 5) | AI_4BYTE);\n    w.writeUint32(Number(v));\n  } else {\n    w.writeByte((mt << 5) | AI_8BYTE);\n    w.writeBigUint64(v);\n  }\n}\n\n/**\n * Encode a CBOR initial byte + argument into a Uint8Array.\n * Convenience wrapper around {@link writeHeadTo} for callers that need the\n * bytes directly (e.g. hex dumps).\n */\nexport function writeHead(\n  mt: number,\n  value: number | bigint,\n  encodingWidth?: EncodingWidth\n): Uint8Array {\n  const w = new CborWriter(9);\n  writeHeadTo(w, mt, value, encodingWidth);\n  return w.finish();\n}\n\n// ─── Float precision helpers ──────────────────────────────────────────────────\n\nconst _f32buf = new DataView(new ArrayBuffer(4));\n\n/**\n * Returns true if `value` can be exactly represented as a float16 without\n * precision loss (including -0, Infinity, -Infinity, NaN identity).\n */\nexport function canEncodeAsFloat16(value: number): boolean {\n  return Object.is(float16BitsToFloat64(float64ToFloat16Bits(value)), value);\n}\n\n/**\n * Returns true if `value` can be exactly represented as a float32 without\n * precision loss.\n */\nexport function canEncodeAsFloat32(value: number): boolean {\n  _f32buf.setFloat32(0, value, false);\n  return Object.is(_f32buf.getFloat32(0, false), value);\n}\n\n/**\n * Choose the smallest float precision that represents `value` exactly.\n * Used by CborFloat.toCBOR() when `precision` is undefined.\n */\nexport function autoSelectFloatPrecision(value: number): FloatPrecision {\n  if (canEncodeAsFloat16(value)) return 'half';\n  if (canEncodeAsFloat32(value)) return 'single';\n  return 'double';\n}\n","import type {\n  CBOROptions,\n  ToCDNOptions,\n  ToJSOptions,\n  ToHexDumpOptions,\n  ToCBOROptions,\n  CborComment,\n  CborComments,\n  DecodeWarning,\n  ParseWarning,\n} from '../types';\nimport { CBOR_OMIT } from '../types';\nimport {\n  convertCommentText,\n  resolveIndent,\n  splitLeadingComments,\n} from '../cdn/serialize-utils';\nimport { CborWriter } from '../cbor/encode';\nimport { bytesToSpacedHexUpper } from '../utils/hex';\n\n/** @internal One line of an annotated hex dump. */\nexport interface AnnotatedLine {\n  depth: number;\n  hex: string;\n  comment: string;\n}\n\nexport interface AppSeqEncodingEdit {\n  /** Start/end offsets within appSeqSource of an existing indicator. */\n  start: number;\n  end: number;\n  /** Replacement used by encodingIndicators: 'always'. */\n  always: string;\n  /** Replacement used by encodingIndicators: 'never'. */\n  never: string;\n}\n\n/**\n * Original literal features used by the sole item inside a preserved\n * `prefix<<item>>` source. They let serialization honour an explicitly\n * disabled sibling `preserve*` option instead of replaying that literal\n * verbatim through `preserveAppSequence`.\n */\nexport interface AppSeqSourceFeatures {\n  byteString?: boolean;\n  textString?: boolean;\n  rawString?: boolean;\n  concatenation?: boolean;\n}\n\n/**\n * Fill in every `preserve*` option left `undefined` with `true`, for\n * `ToCDNOptions.preserveAll` — except the deprecated `preserveTextString`,\n * which no longer participates in `preserveAll`. An option the caller\n * explicitly set (including to `false`) is left untouched.\n */\nfunction expandPreserveAll(options: ToCDNOptions): ToCDNOptions {\n  return {\n    ...options,\n    preserveComments: options.preserveComments ?? true,\n    preserveByteString: options.preserveByteString ?? true,\n    preserveRawString: options.preserveRawString ?? true,\n    preserveConcatenation: options.preserveConcatenation ?? true,\n    preserveNumberFormat: options.preserveNumberFormat ?? true,\n    preserveAppSequence: options.preserveAppSequence ?? true,\n    preserveBlankLines: options.preserveBlankLines ?? true,\n  };\n}\n\n/**\n * Abstract base class for all CBOR AST nodes.\n *\n * Every node can serialize itself to CBOR binary, CDN text, and a\n * plain JavaScript value.  Concrete implementations are provided in each\n * subclass (added in later phases).\n */\nexport abstract class CborItem {\n  /**\n   * Character offset of the first character of this item in the parsed source.\n   * Set by parsers; undefined when the node was constructed directly.\n   * For CBOR input this is a byte offset.\n   */\n  start?: number;\n\n  /**\n   * Character offset just past the last character of this item in the parsed source.\n   * Set by parsers; undefined when the node was constructed directly.\n   * For CBOR input this is a byte offset.\n   */\n  end?: number;\n\n  /**\n   * Comments captured from CDN source when `preserveComments` is enabled.\n   * They do not affect CBOR bytes or JS conversion.\n   */\n  comments?: CborComments;\n\n  /**\n   * `true` when this node is an array/map entry (or indefinite-length\n   * string chunk) immediately preceded by a blank line in the parsed CDN\n   * source — set unconditionally by the parser, regardless of any\n   * `preserve*` option, mirroring `start`/`end`. Only consulted by\n   * `toCDN()` when `ToCDNOptions.preserveBlankLines` is set; otherwise\n   * ignored. Left `undefined` for nodes not parsed as a container entry, or\n   * with no blank line before them.\n   */\n  blankLineBefore?: boolean;\n\n  /**\n   * Original application-string/-sequence source text — `prefix'...'`,\n   * `` prefix`...` ``, or `prefix<<...>>` — set by the parser when the\n   * resolving extension declares `preserveAppSeqSource: 'optional'`. A\n   * subclass's own `_toCDN()` override may check this (gated behind\n   * `ToCDNOptions.preserveAppSequence`) to round-trip the exact original\n   * spelling instead of always regenerating `prefix'...'` notation from the\n   * resolved value. Left `undefined` for nodes not parsed from one of these\n   * forms.\n   */\n  appSeqSource?: string;\n\n  /**\n   * Comments contained within `appSeqSource`, with `start`/`end` offsets\n   * relative to that string. These spans allow comment markers to be\n   * converted (or comments to be removed) without regenerating and thereby\n   * losing the original application-string/-sequence notation.\n   */\n  appSeqComments?: CborComment[];\n\n  /**\n   * Source edits for encoding indicators contained in a raw-tag\n   * `appSeqSource`. Includes zero-width edits where an indicator was absent\n   * so `encodingIndicators: 'always'` can insert one without regenerating\n   * the surrounding source.\n   */\n  appSeqEncodingEdits?: AppSeqEncodingEdit[];\n\n  /**\n   * `false` when `appSeqEncodingEdits` does not cover every encoding\n   * indicator nested inside a raw-tag `appSeqSource` — i.e. its content\n   * contains a node type `collectContentEncodingEdits` doesn't know how to\n   * edit (e.g. a `CborMap`, `CborTag`, or indefinite-length string inside an\n   * `ip` array). Left `undefined` (treated as complete) when coverage is\n   * exhaustive, which holds for every tag content type `dt` accepts and for\n   * most content `ip` accepts. When `false`, `decideTaggedAppSeqRendering`\n   * must not choose the `'source'` decision under `encodingIndicators !==\n   * 'auto'`, since surgical span edits would silently leave the uncovered\n   * node's indicator unchanged; it falls back to `'structural'` instead.\n   */\n  appSeqEncodingEditsComplete?: boolean;\n\n  /**\n   * For an `appSeqSource` parsed from `prefix<<item>>` notation: the offset\n   * within `appSeqSource`, relative to its own start, where the sole inner\n   * item's own consumption ends — i.e. right after its own encoding\n   * indicator, if it had one. Lets `adjustAppSeqIndicator` locate and strip\n   * that inner indicator exactly, regardless of what (whitespace, a\n   * trailing comma, a comment) separates it from the closing `>>`, rather\n   * than pattern-matching text near `>>`. `undefined` when `appSeqSource`\n   * isn't `<<...>>` notation, or wasn't captured with a single inner item.\n   */\n  appSeqInnerEnd?: number;\n\n  /**\n   * Literal-preservation features present in the sole item of a captured\n   * `prefix<<item>>` source. Used to resolve explicitly disabled\n   * `preserve*` options without treating unrelated options as conflicts.\n   */\n  appSeqSourceFeatures?: AppSeqSourceFeatures;\n\n  /**\n   * Validity violations detected while decoding or parsing this node.\n   * Populated when `strict: false` is set in `FromCBOROptions` or\n   * `FromCDNOptions`.\n   */\n  warnings?: (DecodeWarning | ParseWarning)[];\n\n  /**\n   * Default options bound by a {@link CBOR} instance factory method.\n   * Per-call options always take precedence.\n   * @internal\n   */\n  _defaults?: CBOROptions;\n\n  /**\n   * @internal\n   * True when this node is, or contains through wrapper nodes (tags,\n   * app-sequence results), an array or map. `inlineLeafContainers` never\n   * inlines a container whose entries contain another container, even one\n   * that renders on a single line. `CborEmbeddedCBOR` (`<<...>>`) is the one\n   * exception: it inlines its own entries based purely on whether they\n   * render without a line break, regardless of this flag — see its\n   * `_toCDN()`, which omits `entryIsLeaf` for that reason.\n   */\n  get _containsCdnContainer(): boolean {\n    return false;\n  }\n\n  // ─── Public template methods ────────────────────────────────────────────────\n\n  /** Serialize this node to CBOR binary. */\n  toCBOR(options?: ToCBOROptions): Uint8Array {\n    const merged = this._defaults ? { ...this._defaults, ...options } : options;\n    const writer = new CborWriter();\n    this._encode(writer, merged);\n    return writer.finish();\n  }\n\n  /** Serialize this node to a CDN text string. */\n  toCDN(options?: ToCDNOptions): string {\n    let merged = this._defaults ? { ...this._defaults, ...options } : options;\n    if (merged?.preserveAll) merged = expandPreserveAll(merged);\n    const body = this._toCDN(merged, 0);\n    const pv = merged?.preserveComments;\n    // Single-line output strips comments: `#`/`//` comments need a newline\n    // to terminate, so they cannot be emitted without breaking the guarantee\n    // that single-line output contains no newlines.\n    if (!pv || resolveIndent(merged) === null) return body;\n    const style = typeof pv === 'string' ? pv : undefined;\n    const { ownLines, inlinePrefix } = splitLeadingComments(this, '', style);\n    const trailing = this.comments?.trailing ?? [];\n    const bodyWithTrailing =\n      trailing.length === 0\n        ? body\n        : `${body} ${trailing.map((c) => convertCommentText(c, style).trimEnd()).join(' ')}`;\n    return [...ownLines, `${inlinePrefix}${bodyWithTrailing}`].join('\\n');\n  }\n\n  /**\n   * Serialize this node to a CDN text string.\n   *\n   * @deprecated Use `toCDN()` instead.\n   */\n  toEDN(options?: ToCDNOptions): string {\n    return this.toCDN(options);\n  }\n\n  /**\n   * Convert this CBOR AST node to a plain JavaScript value.\n   *\n   * If `options.reviver` is supplied it is called with key `''` on the root\n   * result after the full tree has been converted (matching the semantics of\n   * `JSON.parse`).  Container nodes call the reviver on each of their direct\n   * children during conversion, so the walk is bottom-up.\n   */\n  toJS(options?: ToJSOptions): unknown {\n    const merged = this._defaults ? { ...this._defaults, ...options } : options;\n    const result = this._toJS(merged);\n    if (!merged?.reviver) return result;\n    const rv = merged.reviver.call({ '': result }, '', result);\n    return rv === CBOR_OMIT ? undefined : rv;\n  }\n\n  /**\n   * Generate an RFC 8949 §3 style annotated hex dump of this value.\n   *\n   * @example\n   * const cbor = CBOR.fromCDN('[_ 1, [2, 3]]');\n   * console.log(cbor.toHexDump());\n   * // 9F        -- Start indefinite-length array\n   * //    01     -- 1\n   * //    82     -- Array of length 2\n   * //       02  -- 2\n   * //       03  -- 3\n   * //    FF     -- \"break\"\n   * // FF        -- \"break\"\n   */\n  toHexDump(options?: ToHexDumpOptions): string {\n    const merged = this._defaults ? { ...this._defaults, ...options } : options;\n    const raw = merged?.indent ?? 3;\n    const indentStr = typeof raw === 'string' ? raw : ' '.repeat(raw);\n    const marker = (merged?.commentStyle ?? '--') + ' ';\n    const lines = this._toHexDump(0, merged);\n    // A plain loop, not Math.max(...spread): spreading one argument per line\n    // overflows the call stack for items with hundreds of thousands of lines.\n    let maxPrefixLen = 0;\n    for (const l of lines) {\n      const prefixLen = l.depth * indentStr.length + l.hex.length;\n      if (prefixLen > maxPrefixLen) maxPrefixLen = prefixLen;\n    }\n    const col = maxPrefixLen + 2;\n    return lines\n      .map((l) => {\n        const prefix = indentStr.repeat(l.depth) + l.hex;\n        return prefix.padEnd(col) + marker + l.comment;\n      })\n      .join('\\n');\n  }\n\n  // ─── Internal abstract methods ───────────────────────────────────────────────\n\n  /**\n   * @internal\n   * Encode this node into `writer`, honoring `_toCBOR()` overrides.\n   *\n   * This is the entry point used by `toCBOR()` and by container nodes when\n   * recursing into children.  A subclass that overrides `_toCBOR()` (e.g. to\n   * emit a pre-computed bit pattern) is authoritative even when one of its\n   * built-in base classes implements `_encodeTo()`.\n   */\n  _encode(writer: CborWriter, options?: ToCBOROptions): void {\n    if (this._toCBOR !== CborItem.prototype._toCBOR) {\n      writer.writeBytes(this._toCBOR(options));\n      return;\n    }\n    this._encodeTo(writer, options);\n  }\n\n  /**\n   * @internal\n   * Write this node's CBOR encoding into `writer`.\n   *\n   * Built-in nodes override this so that an entire encode pass shares one\n   * growing buffer (no per-node Uint8Array allocations or re-copies).\n   * Container implementations must recurse via `child._encode()`, never\n   * `child._encodeTo()`, so that `_toCBOR()` overrides are honored.\n   */\n  _encodeTo(writer: CborWriter, options?: ToCBOROptions): void {\n    if (this._toCBOR === CborItem.prototype._toCBOR)\n      throw new TypeError(\n        'CborItem subclass must implement _encodeTo() or _toCBOR()'\n      );\n    writer.writeBytes(this._toCBOR(options));\n  }\n\n  /**\n   * @internal\n   * Subclass CBOR encoding implementation.\n   * The default builds the bytes via `_encodeTo()`; subclasses may instead\n   * override this method directly when producing a standalone byte array is\n   * more natural (e.g. emitting a pre-computed bit pattern).\n   */\n  _toCBOR(options?: ToCBOROptions): Uint8Array {\n    const writer = new CborWriter();\n    this._encodeTo(writer, options);\n    return writer.finish();\n  }\n\n  /**\n   * @internal\n   * Depth-aware CDN serialization.\n   * Leaf nodes receive `depth` but may ignore it.\n   * Container nodes use `depth` for indentation and call\n   * `child._toCDN(options, depth + 1)` when recursing.\n   */\n  abstract _toCDN(options: ToCDNOptions | undefined, depth: number): string;\n\n  /**\n   * @internal\n   * Core conversion logic implemented by each subclass.\n   * Container nodes apply `options.reviver` to their direct children.\n   * Do not call this directly — use `toJS()` instead.\n   */\n  abstract _toJS(options?: ToJSOptions): unknown;\n\n  /**\n   * @internal\n   * Collect annotated-hex lines for this node.\n   * Leaf nodes emit a single line; container nodes override to emit\n   * open/close lines with recursively collected children.\n   */\n  _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[] {\n    const hex = bytesToSpacedHexUpper(this._toCBOR());\n    return [{ depth, hex, comment: this._toCDN(options, 0) }];\n  }\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CborItem } from './CborItem';\nimport { MT_UINT } from '../cbor/constants';\nimport {\n  writeHeadTo,\n  type CborWriter,\n  type EncodingWidth,\n} from '../cbor/encode';\nimport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n} from '../cdn/serialize-utils';\n\n/** CBOR Major Type 0 — unsigned integer (0 … 2^64−1). */\nexport class CborUint extends CborItem {\n  readonly value: bigint;\n  encodingWidth: EncodingWidth | undefined;\n  /**\n   * Original CDN digit spelling (base + digits, without the encoding-\n   * indicator suffix), set by the parser when this value came from CDN\n   * text. Used by `_toCDN()` to round-trip the literal's base (`0xff`,\n   * `0o377`, `0b101`, decimal) when `preserveNumberFormat` is set.\n   */\n  readonly ednSource?: string;\n\n  constructor(\n    value: number | bigint,\n    options?: { encodingWidth?: EncodingWidth; ednSource?: string }\n  ) {\n    super();\n    this.value = BigInt(value);\n    if (this.value < 0n)\n      throw new RangeError('CborUint value must be non-negative');\n    if (this.value > 0xffff_ffff_ffff_ffffn)\n      throw new RangeError('CborUint value exceeds maximum uint64');\n    this.encodingWidth = options?.encodingWidth;\n    this.ednSource = options?.ednSource;\n  }\n\n  override _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void {\n    writeHeadTo(writer, MT_UINT, this.value, this.encodingWidth);\n  }\n\n  _toCDN(options: ToCDNOptions | undefined, _depth: number): string {\n    const suffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(this.value)\n    );\n    if (options?.preserveNumberFormat && this.ednSource !== undefined) {\n      return this.ednSource + suffix;\n    }\n    const v = this.value;\n    switch (options?.intFormat) {\n      case 'hex':\n        return `0x${v.toString(16)}${suffix}`;\n      case 'octal':\n        return `0o${v.toString(8)}${suffix}`;\n      case 'binary':\n        return `0b${v.toString(2)}${suffix}`;\n      default:\n        return v.toString() + suffix;\n    }\n  }\n\n  _toJS(options?: ToJSOptions): unknown {\n    const mode = options?.integerAs ?? 'auto';\n    if (mode === 'bigint') return this.value;\n    if (mode === 'number') return Number(this.value);\n    return this.value <= BigInt(Number.MAX_SAFE_INTEGER)\n      ? Number(this.value)\n      : this.value;\n  }\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CborItem } from './CborItem';\nimport { MT_NINT } from '../cbor/constants';\nimport {\n  writeHeadTo,\n  type CborWriter,\n  type EncodingWidth,\n} from '../cbor/encode';\nimport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n} from '../cdn/serialize-utils';\n\n/**\n * CBOR Major Type 1 — negative integer (−2^64 … −1).\n *\n * The constructor accepts the actual negative value (e.g. `-5n`).\n * Internally the CBOR \"argument\" `n` is stored, where the decoded value\n * equals `−1 − n`.  This matches the wire encoding directly.\n *\n * Examples:\n *   new CborNint(-1n)  → argument = 0n\n *   new CborNint(-5n)  → argument = 4n\n */\nexport class CborNint extends CborItem {\n  /** CBOR raw argument n, where actual value = −1 − n. */\n  readonly argument: bigint;\n  encodingWidth: EncodingWidth | undefined;\n  /**\n   * Original CDN digit spelling (sign + base + digits, without the\n   * encoding-indicator suffix), set by the parser when this value came\n   * from CDN text. Used by `_toCDN()` to round-trip the literal's base\n   * (`-0xff`, `-0o377`, `-0b101`, decimal) when `preserveNumberFormat` is\n   * set.\n   */\n  readonly ednSource?: string;\n\n  constructor(\n    value: number | bigint,\n    options?: { encodingWidth?: EncodingWidth; ednSource?: string }\n  ) {\n    super();\n    const v = BigInt(value);\n    if (v >= 0n) throw new RangeError('CborNint value must be negative');\n    if (v < -(0xffff_ffff_ffff_ffffn + 1n))\n      throw new RangeError('CborNint value exceeds minimum int64');\n    this.argument = -1n - v;\n    this.encodingWidth = options?.encodingWidth;\n    this.ednSource = options?.ednSource;\n  }\n\n  /** The actual decoded negative value (−1 − argument). */\n  get value(): bigint {\n    return -1n - this.argument;\n  }\n\n  override _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void {\n    writeHeadTo(writer, MT_NINT, this.argument, this.encodingWidth);\n  }\n\n  _toCDN(options: ToCDNOptions | undefined, _depth: number): string {\n    const suffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(this.argument)\n    );\n    if (options?.preserveNumberFormat && this.ednSource !== undefined) {\n      return this.ednSource + suffix;\n    }\n    const abs = this.argument + 1n; // absolute value of the negative number\n    switch (options?.intFormat) {\n      case 'hex':\n        return `-0x${abs.toString(16)}${suffix}`;\n      case 'octal':\n        return `-0o${abs.toString(8)}${suffix}`;\n      case 'binary':\n        return `-0b${abs.toString(2)}${suffix}`;\n      default:\n        return this.value.toString() + suffix;\n    }\n  }\n\n  _toJS(options?: ToJSOptions): unknown {\n    const v = this.value;\n    const mode = options?.integerAs ?? 'auto';\n    if (mode === 'bigint') return v;\n    if (mode === 'number') return Number(v);\n    return v >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(v) : v;\n  }\n}\n","/**\n * Hex float (C99-style, e.g. `0x1.8p+0`) encode/decode utilities.\n *\n * Hex float format:\n *   [-] 0x [hex digits] [. [hex digits]] p [+-] [decimal exponent]\n *\n * This notation appears in CDN (draft-ietf-cbor-edn-literals-25) as an\n * alternative representation for floating-point values (major type 7).\n */\n\n// Reusable 8-byte buffer for float64 bit extraction\nconst _buf8 = new ArrayBuffer(8);\nconst _dv8 = new DataView(_buf8);\n\n/**\n * Parse a hex float literal (e.g. `0x4711p+03`, `0x1.8p+0`, `-0x1.fp-2`)\n * to a JS number.\n *\n * Assumes the string has already been stripped of any encoding-indicator\n * suffix (`_1`, `_2`, `_3`).\n */\nexport function parseHexFloat(s: string): number {\n  const neg = s.startsWith('-');\n  const body = s.slice(neg ? 3 : 2); // strip optional '-' and '0x'/'0X'\n\n  const pIdx = body.search(/[pP]/);\n  if (pIdx === -1)\n    throw new SyntaxError(\n      `EDN parse error: hex float missing 'p' exponent: ${s}`\n    );\n\n  const mantissaStr = body.slice(0, pIdx);\n  const expStr = body.slice(pIdx + 1);\n\n  // Exponent must be a non-empty decimal integer (optional sign + digits)\n  if (!/^[+-]?\\d+$/.test(expStr))\n    throw new SyntaxError(\n      `EDN parse error: hex float has invalid or missing exponent: ${s}`\n    );\n\n  const exp = parseInt(expStr, 10);\n\n  const dotIdx = mantissaStr.indexOf('.');\n  let mantissa: number;\n  if (dotIdx === -1) {\n    // No decimal point: must have at least one hex digit\n    if (!/^[0-9a-fA-F]+$/.test(mantissaStr))\n      throw new SyntaxError(\n        `EDN parse error: hex float has no mantissa digits: ${s}`\n      );\n    mantissa = parseInt(mantissaStr, 16);\n  } else {\n    const intPart = mantissaStr.slice(0, dotIdx);\n    const fracStr = mantissaStr.slice(dotIdx + 1);\n    // At least one hex digit required on either side of the decimal point\n    if (intPart === '' && fracStr === '')\n      throw new SyntaxError(\n        `EDN parse error: hex float has no mantissa digits: ${s}`\n      );\n    if (intPart !== '' && !/^[0-9a-fA-F]+$/.test(intPart))\n      throw new SyntaxError(\n        `EDN parse error: hex float has invalid mantissa: ${s}`\n      );\n    if (fracStr !== '' && !/^[0-9a-fA-F]+$/.test(fracStr))\n      throw new SyntaxError(\n        `EDN parse error: hex float has invalid mantissa: ${s}`\n      );\n    const intVal = intPart === '' ? 0 : parseInt(intPart, 16);\n    const fracVal =\n      fracStr === '' ? 0 : parseInt(fracStr, 16) / Math.pow(16, fracStr.length);\n    mantissa = intVal + fracVal;\n  }\n\n  const result = mantissa * Math.pow(2, exp);\n  return neg ? -result : result;\n}\n\n/**\n * Convert a JS number to a normalized hex float string compatible with\n * CDN diagnostic notation.\n *\n * - Normal values: `0x1.[hex fraction]p[+-][exp]`  (e.g. `0x1.8p+0` for 1.5)\n * - Subnormal values: `0x0.[hex fraction]p-1022`\n * - Zero: `0x0p+0` / `-0x0p+0`\n * - Non-finite values (NaN, ±Infinity) are returned unchanged as EDN tokens.\n */\nexport function floatToHexFloat(v: number): string {\n  if (isNaN(v)) return 'NaN';\n  if (!isFinite(v)) return v > 0 ? 'Infinity' : '-Infinity';\n\n  const neg = Object.is(v, -0) || v < 0;\n  const abs = Math.abs(v);\n\n  if (abs === 0) return neg ? '-0x0p+0' : '0x0p+0';\n\n  _dv8.setFloat64(0, abs, false); // big-endian\n  const hi = _dv8.getUint32(0, false);\n  const lo = _dv8.getUint32(4, false);\n\n  // bits [30:20] of hi = biased exponent (11 bits)\n  const biasedExp = (hi >>> 20) & 0x7ff;\n  // bits [19:0] of hi = upper 20 bits of 52-bit mantissa\n  const mantHi = hi & 0xfffff;\n  // lo = lower 32 bits of mantissa\n  const mantLo = lo;\n\n  // Format mantissa as 13 hex digits (52 bits / 4), strip trailing zeros\n  const hexMant =\n    mantHi.toString(16).padStart(5, '0') + mantLo.toString(16).padStart(8, '0');\n  const trimmed = hexMant.replace(/0+$/, '');\n  const mantPart = trimmed === '' ? '' : `.${trimmed}`;\n\n  let intPart: string;\n  let exp: number;\n  if (biasedExp === 0) {\n    // Subnormal: value = 0.[mantissa] * 2^-1022\n    intPart = '0';\n    exp = -1022;\n  } else {\n    // Normal: value = 1.[mantissa] * 2^(biasedExp-1023)\n    intPart = '1';\n    exp = biasedExp - 1023;\n  }\n\n  const expStr = exp >= 0 ? `+${exp}` : `${exp}`;\n  const result = `0x${intPart}${mantPart}p${expStr}`;\n  return neg ? `-${result}` : result;\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CborItem } from './CborItem';\nimport { MT_SIMPLE, AI_2BYTE, AI_4BYTE, AI_8BYTE } from '../cbor/constants';\nimport { autoSelectFloatPrecision, type CborWriter } from '../cbor/encode';\nimport {\n  floatValueToString,\n  floatSuffix,\n  resolveIndent,\n} from '../cdn/serialize-utils';\nimport { floatToHexFloat } from '../utils/hexfloat';\n\nexport type FloatPrecision = 'half' | 'single' | 'double';\n\n/**\n * CBOR Major Type 7 — IEEE 754 floating-point number.\n *\n * `precision` records the encoding size from the original CBOR stream so\n * that lossless round-trips are preserved.  When constructing from a JS\n * `number`, omit `precision` (`undefined`) and the encoder will choose\n * the smallest encoding that preserves the value exactly.\n */\nexport class CborFloat extends CborItem {\n  readonly value: number;\n  /**\n   * Encoding size hint.\n   * - `'half'` / `'single'` / `'double'`: use exactly this size (set by the\n   *   decoder to guarantee lossless round-trips).\n   * - `undefined`: encoder auto-selects the smallest lossless size.\n   */\n  precision: FloatPrecision | undefined;\n  /**\n   * Original app-string source (e.g. `float'7e00'`), set by the parser when\n   * this float is the result of a `float'...'` app-string.  Used by toCDN()\n   * to round-trip the literal when `appStrings` is not false.\n   */\n  ednSource?: string;\n\n  /**\n   * Original CDN literal source text (e.g. `1.50`, `1.5_1`, `0x1.8p+0_1`),\n   * set by the parser when this float came from a plain CDN float literal\n   * (as opposed to a `float'...'` app-string, which uses `ednSource`\n   * above). Used by `_toCDN()` to round-trip the literal's exact spelling,\n   * including its encoding-indicator suffix, when `preserveNumberFormat`\n   * is set.\n   */\n  literalSource?: string;\n\n  /**\n   * Original encoded payload bytes (big-endian, without the initial byte),\n   * set by the decoder when the value is NaN so that NaN payloads survive a\n   * decode → encode round-trip (a JS `number` cannot carry them).\n   * Used by the encoder only when `value` is NaN and the length matches the\n   * byte size of the encoded `precision`; ignored otherwise.\n   */\n  rawBits?: Uint8Array;\n\n  constructor(\n    value: number,\n    options?: {\n      precision?: FloatPrecision;\n      rawBits?: Uint8Array;\n      literalSource?: string;\n    }\n  ) {\n    super();\n    this.value = value;\n    this.precision = options?.precision;\n    this.rawBits = options?.rawBits;\n    this.literalSource = options?.literalSource;\n  }\n\n  override _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void {\n    const precision = this.precision ?? autoSelectFloatPrecision(this.value);\n    const initial = MT_SIMPLE << 5;\n    // rawBits carries a NaN payload only; for any other value it would let\n    // the encoded bytes contradict `value`, so it is ignored.\n    const rawBits = Number.isNaN(this.value) ? this.rawBits : undefined;\n\n    if (precision === 'half') {\n      writer.writeByte(initial | AI_2BYTE); // 0xf9\n      if (rawBits?.length === 2) writer.writeBytes(rawBits);\n      else writer.writeFloat16(this.value);\n    } else if (precision === 'single') {\n      writer.writeByte(initial | AI_4BYTE); // 0xfa\n      if (rawBits?.length === 4) writer.writeBytes(rawBits);\n      else writer.writeFloat32(this.value);\n    } else {\n      // double\n      writer.writeByte(initial | AI_8BYTE); // 0xfb\n      if (rawBits?.length === 8) writer.writeBytes(rawBits);\n      else writer.writeFloat64(this.value);\n    }\n  }\n\n  _toCDN(options: ToCDNOptions | undefined, _depth: number): string {\n    const mode = options?.encodingIndicators ?? 'auto';\n    // In single-line output (no `indent`), a source spelling that spans\n    // multiple lines (e.g. a `float<<...>>` app-sequence written across\n    // lines) cannot be re-emitted, so it falls back to normal serialization.\n    if (\n      options?.appStrings !== false &&\n      this.ednSource !== undefined &&\n      (resolveIndent(options) !== null || !/[\\r\\n]/.test(this.ednSource))\n    ) {\n      const ednSource = this.ednSource;\n      if (mode === 'never') return ednSource.replace(/_[0-3i]$/, '');\n      if (mode === 'always') {\n        if (/_[0-3i]$/.test(ednSource)) return ednSource;\n        const actual = this.precision ?? autoSelectFloatPrecision(this.value);\n        const suffix =\n          actual === 'half' ? '_1' : actual === 'single' ? '_2' : '_3';\n        return ednSource + suffix;\n      }\n      return ednSource;\n    }\n    if (options?.preserveNumberFormat && this.literalSource !== undefined) {\n      const literalSource = this.literalSource;\n      // Encoding-indicator suffixes are embedded directly in the literal\n      // text; _[0-7i] matches the full grammar (not just _[0-3i]) so that a\n      // syntactically-present-but-semantically-invalid suffix (e.g. the \"_7\"\n      // in a leniently-parsed \"1.5_7\") is still recognised and stripped.\n      if (mode === 'never') return literalSource.replace(/_[0-7i]$/, '');\n      if (mode === 'always') {\n        if (/_[0-7i]$/.test(literalSource)) return literalSource;\n        const autoSelected = autoSelectFloatPrecision(this.value);\n        return (\n          literalSource +\n          floatSuffix(this.value, this.precision, autoSelected, 'always')\n        );\n      }\n      return literalSource;\n    }\n    const autoSelected = autoSelectFloatPrecision(this.value);\n    const numStr =\n      options?.floatFormat === 'hex'\n        ? floatToHexFloat(this.value)\n        : floatValueToString(this.value);\n    return numStr + floatSuffix(this.value, this.precision, autoSelected, mode);\n  }\n\n  _toJS(_options?: ToJSOptions): unknown {\n    return this.value;\n  }\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CborItem } from './CborItem';\nimport { Tag } from '../tag';\nimport type { AnnotatedLine } from './CborItem';\nimport { MT_TAG } from '../cbor/constants';\nimport {\n  writeHead,\n  writeHeadTo,\n  type CborWriter,\n  type EncodingWidth,\n} from '../cbor/encode';\nimport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n  renderSingleChildWithComments,\n} from '../cdn/serialize-utils';\nimport { bytesToSpacedHexUpper } from '../utils/hex';\n\n/** CBOR Major Type 6 — tagged data item. */\nexport class CborTag extends CborItem {\n  readonly tag: bigint;\n  readonly content: CborItem;\n  encodingWidth: EncodingWidth | undefined;\n  /**\n   * Original CDN digit spelling of the tag number (base + digits, without\n   * the encoding-indicator suffix), set by the parser when this tag came\n   * from CDN text. Used by `_toCDN()` to round-trip the tag number's base\n   * (`0x3e7`, decimal, …) when `preserveNumberFormat` is set.\n   */\n  ednSource?: string;\n\n  constructor(\n    tag: number | bigint,\n    content: CborItem,\n    options?: { encodingWidth?: EncodingWidth; ednSource?: string }\n  ) {\n    super();\n    this.tag = BigInt(tag);\n    if (this.tag < 0n)\n      throw new RangeError('CborTag tag number must be non-negative');\n    this.content = content;\n    this.encodingWidth = options?.encodingWidth;\n    this.ednSource = options?.ednSource;\n  }\n\n  override get _containsCdnContainer(): boolean {\n    return this.content._containsCdnContainer;\n  }\n\n  override _encodeTo(writer: CborWriter, options?: ToCBOROptions): void {\n    writeHeadTo(writer, MT_TAG, this.tag, this.encodingWidth);\n    this.content._encode(writer, options);\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    const suffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(this.tag)\n    );\n    const tagStr =\n      options?.preserveNumberFormat && this.ednSource !== undefined\n        ? this.ednSource\n        : this.tag.toString();\n    const wrapped = renderSingleChildWithComments(\n      this.content,\n      this,\n      options,\n      depth,\n      (childDepth) => this.content._toCDN(options, childDepth),\n      '(',\n      ')'\n    );\n    return `${tagStr}${suffix}${wrapped}`;\n  }\n\n  override _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[] {\n    const lines: AnnotatedLine[] = [\n      {\n        depth,\n        hex: bytesToSpacedHexUpper(\n          writeHead(MT_TAG, this.tag, this.encodingWidth)\n        ),\n        comment: `Tag ${this.tag}`,\n      },\n    ];\n    lines.push(\n      ...this.content._toHexDump(depth + 1, { ...options, appStrings: false })\n    );\n    return lines;\n  }\n\n  _toJS(options?: ToJSOptions): unknown {\n    const value = this.content._toJS(options);\n    return options?.stripTags ? value : Tag.set(value, this.tag);\n  }\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CborItem } from './CborItem';\nimport { MT_BYTES } from '../cbor/constants';\nimport {\n  writeHeadTo,\n  type CborWriter,\n  type EncodingWidth,\n} from '../cbor/encode';\nimport {\n  serializeBytes,\n  resolveEiSuffix,\n  resolveIndent,\n  joinConcatParts,\n  canonicalEncodingWidth,\n  stripByteLiteralComments,\n  danglingCommentsByGap,\n  type ByteCommentSyntax,\n} from '../cdn/serialize-utils';\n\n/**\n * A preserved literal source, with any embedded comment stripped unless\n * `preserveComments` is set — the preserved spelling should still drop\n * comments by default, the same as an unpreserved literal re-derived from\n * its decoded value would. `commentSyntax` is `undefined` for a literal\n * family with no comment syntax at all (bare sqstr `'...'`) or one whose\n * comment syntax isn't known (an app-string extension other than the\n * specific built-in `b32`/`h32` objects — see `ednCommentSyntax`); in\n * either case the source is returned verbatim, since there's nothing safe\n * to strip.\n */\nfunction preservedSource(\n  source: string | undefined,\n  options: ToCDNOptions | undefined,\n  commentSyntax: ByteCommentSyntax | undefined\n): string | undefined {\n  if (source === undefined) return undefined;\n  if (options?.preserveComments || commentSyntax === undefined) return source;\n  return stripByteLiteralComments(source, commentSyntax);\n}\n\n/** One part of a byte string parsed from a CDN `+` concatenation chain. */\nexport interface CborByteStringPart {\n  bytes: Uint8Array;\n  /** Original literal source text, when the part came from a byte string token. */\n  source?: string;\n  /** Which comment syntax `source` recognizes, if any — see `ednCommentSyntax`. */\n  commentSyntax?: ByteCommentSyntax;\n  /**\n   * Source span of this part's own literal token, when known — used to place\n   * a comment sitting between two `+`-joined parts (attached to the whole\n   * `CborByteString` as a `dangling` comment, since there is no per-part AST\n   * node for it to attach to) at the right gap in `_toCDN`'s\n   * `preserveConcatenation` branch. `undefined` for a part merged from a\n   * single elided literal's own internal segments, which cannot have a\n   * comment between them.\n   */\n  start?: number;\n  end?: number;\n}\n\n/** CBOR Major Type 2 — definite-length byte string. */\nexport class CborByteString extends CborItem {\n  readonly indefiniteLength = false as const;\n  readonly value: Uint8Array;\n  /** Preferred EDN encoding for this byte string. */\n  readonly ednEncoding: 'hex' | 'base64' | 'base64url' | 'base32' | 'base32hex';\n  encodingWidth: EncodingWidth | undefined;\n  readonly ednSource: string | undefined;\n  /**\n   * Which comment syntax `ednSource` recognizes, if any — set once at parse\n   * time by whoever actually knows the literal's real origin (see\n   * `ByteCommentSyntax`), never re-derived later from its prefix string:\n   * a user extension can register under any prefix, including one a\n   * built-in (`b32`/`h32`) also uses, so the prefix string alone can't say\n   * which comment rules (if any) actually apply. `undefined` when\n   * `ednSource` has no comment syntax, or its extension's isn't known.\n   */\n  readonly ednCommentSyntax: ByteCommentSyntax | undefined;\n  /** Part boundaries of the original `+` concatenation chain, if any. */\n  readonly ednParts: readonly CborByteStringPart[] | undefined;\n\n  constructor(\n    value: Uint8Array,\n    options?: {\n      ednEncoding?: 'hex' | 'base64' | 'base64url' | 'base32' | 'base32hex';\n      encodingWidth?: EncodingWidth;\n      ednSource?: string;\n      ednCommentSyntax?: ByteCommentSyntax;\n      ednParts?: readonly CborByteStringPart[];\n    }\n  ) {\n    super();\n    this.value = value;\n    this.ednEncoding = options?.ednEncoding ?? 'hex';\n    this.encodingWidth = options?.encodingWidth;\n    this.ednSource = options?.ednSource;\n    this.ednCommentSyntax = options?.ednCommentSyntax;\n    this.ednParts = options?.ednParts;\n  }\n\n  override _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void {\n    writeHeadTo(writer, MT_BYTES, this.value.length, this.encodingWidth);\n    writer.writeBytes(this.value);\n  }\n\n  _toCDN(options: ToCDNOptions | undefined, _depth: number): string {\n    const indentStr = resolveIndent(options);\n    if (\n      options?.preserveConcatenation &&\n      // Preserved concatenation is a layout feature; single-line mode joins\n      // the parts into one literal instead.\n      indentStr !== null &&\n      this.ednParts !== undefined &&\n      this.ednParts.length > 1\n    ) {\n      const suffix = resolveEiSuffix(options, this.encodingWidth, () =>\n        canonicalEncodingWidth(BigInt(this.value.length))\n      );\n      let encoding = options?.bstrEncoding ?? this.ednEncoding;\n      if (options?.appStrings === false && encoding !== 'hex') encoding = 'hex';\n      const literals = this.ednParts.map((part) => {\n        const source = options?.preserveByteString\n          ? preservedSource(part.source, options, part.commentSyntax)\n          : undefined;\n        return source !== undefined\n          ? source\n          : serializeBytes(part.bytes, encoding, options?.sqstr);\n      });\n      literals[literals.length - 1] += suffix;\n      const midComments = options?.preserveComments\n        ? danglingCommentsByGap(\n            this.comments?.dangling,\n            this.ednParts,\n            typeof options.preserveComments === 'string'\n              ? options.preserveComments\n              : undefined\n          )\n        : undefined;\n      return joinConcatParts(literals, indentStr, _depth, midComments);\n    }\n    const preservedWhole = options?.preserveByteString\n      ? preservedSource(this.ednSource, options, this.ednCommentSyntax)\n      : undefined;\n    if (\n      preservedWhole !== undefined &&\n      // In single-line mode a spelling that spans multiple lines (e.g. a\n      // byte string with an interior line comment that survived stripping,\n      // or a genuine interior line break) cannot be re-emitted.\n      (indentStr !== null || !/[\\r\\n]/.test(preservedWhole))\n    ) {\n      // App-string byte strings (e.g. b32'...'_1) embed the EI inside ednSource.\n      // Regular byte strings (h'...', b64'...') store EI separately in encodingWidth.\n      if (/_[0-3i]$/.test(preservedWhole)) {\n        const mode = options?.encodingIndicators ?? 'auto';\n        if (mode === 'never') return preservedWhole.replace(/_[0-3i]$/, '');\n        return preservedWhole; // 'auto' or 'always': EI already present\n      }\n      const suffix = resolveEiSuffix(options, this.encodingWidth, () =>\n        canonicalEncodingWidth(BigInt(this.value.length))\n      );\n      return preservedWhole + suffix;\n    }\n    const suffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(BigInt(this.value.length))\n    );\n    let encoding = options?.bstrEncoding ?? this.ednEncoding;\n    if (options?.appStrings === false && encoding !== 'hex') encoding = 'hex';\n    return serializeBytes(this.value, encoding, options?.sqstr) + suffix;\n  }\n\n  _toJS(_options?: ToJSOptions): unknown {\n    return this.value;\n  }\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CborItem } from './CborItem';\nimport type { AnnotatedLine } from './CborItem';\nimport { CborByteString } from './CborByteString';\nimport { MT_BYTES, AI_INDEFINITE, BREAK_CODE } from '../cbor/constants';\nimport type { CborWriter } from '../cbor/encode';\nimport {\n  formatTrailingComments,\n  hasPreservedComments,\n  serializeContainer,\n} from '../cdn/serialize-utils';\nimport { byteToHexUpper } from '../utils/hex';\n\n/** CBOR Major Type 2 — indefinite-length byte string (chunked). */\nexport class CborIndefiniteByteString extends CborItem {\n  readonly indefiniteLength = true as const;\n  readonly chunks: CborByteString[];\n\n  constructor(chunks: CborByteString[]) {\n    super();\n    this.chunks = chunks;\n  }\n\n  override _encodeTo(writer: CborWriter, options?: ToCBOROptions): void {\n    writer.writeByte((MT_BYTES << 5) | AI_INDEFINITE);\n    for (const chunk of this.chunks) chunk._encode(writer, options);\n    writer.writeByte(BREAK_CODE);\n  }\n\n  _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    if ((options?.encodingIndicators ?? 'auto') === 'never') {\n      const totalLen = this.chunks.reduce((sum, c) => sum + c.value.length, 0);\n      const merged = new Uint8Array(totalLen);\n      let offset = 0;\n      for (const chunk of this.chunks) {\n        merged.set(chunk.value, offset);\n        offset += chunk.value.length;\n      }\n      return new CborByteString(merged)._toCDN(options, depth);\n    }\n    if (this.chunks.length === 0) return \"''_\";\n    return serializeContainer({\n      node: this,\n      options,\n      depth,\n      openChar: '(',\n      closeChar: ')',\n      count: this.chunks.length,\n      indefiniteLength: true,\n      encodingWidth: undefined,\n      hasEntryComments: () => this.chunks.some(hasPreservedComments),\n      renderEntry: (i) => this.chunks[i]._toCDN(options, depth + 1),\n      entryLeadingNode: (i) => this.chunks[i],\n      entryTrailing: (i, style) =>\n        formatTrailingComments(this.chunks[i], style),\n    });\n  }\n\n  override _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[] {\n    const lines: AnnotatedLine[] = [\n      {\n        depth,\n        hex: byteToHexUpper((MT_BYTES << 5) | AI_INDEFINITE),\n        comment: 'Start indefinite-length byte string',\n      },\n    ];\n    for (const chunk of this.chunks)\n      lines.push(...chunk._toHexDump(depth + 1, options));\n    lines.push({ depth, hex: byteToHexUpper(BREAK_CODE), comment: '\"break\"' });\n    return lines;\n  }\n\n  _toJS(_options?: ToJSOptions): unknown {\n    const totalLen = this.chunks.reduce((sum, c) => sum + c.value.length, 0);\n    const result = new Uint8Array(totalLen);\n    let offset = 0;\n    for (const chunk of this.chunks) {\n      result.set(chunk.value, offset);\n      offset += chunk.value.length;\n    }\n    return result;\n  }\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CborItem } from './CborItem';\nimport type { AnnotatedLine } from './CborItem';\nimport { CborTextString } from './CborTextString';\nimport { MT_TEXT, AI_INDEFINITE, BREAK_CODE } from '../cbor/constants';\nimport type { CborWriter } from '../cbor/encode';\nimport {\n  formatTrailingComments,\n  hasPreservedComments,\n  serializeContainer,\n} from '../cdn/serialize-utils';\nimport { byteToHexUpper } from '../utils/hex';\n\n/** CBOR Major Type 3 — indefinite-length UTF-8 text string (chunked). */\nexport class CborIndefiniteTextString extends CborItem {\n  readonly indefiniteLength = true as const;\n  readonly chunks: CborTextString[];\n\n  constructor(chunks: CborTextString[]) {\n    super();\n    this.chunks = chunks;\n  }\n\n  override _encodeTo(writer: CborWriter, options?: ToCBOROptions): void {\n    writer.writeByte((MT_TEXT << 5) | AI_INDEFINITE);\n    for (const chunk of this.chunks) chunk._encode(writer, options);\n    writer.writeByte(BREAK_CODE);\n  }\n\n  _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    if ((options?.encodingIndicators ?? 'auto') === 'never') {\n      const merged = this.chunks.map((c) => c.value).join('');\n      return new CborTextString(merged)._toCDN(options, depth);\n    }\n    if (this.chunks.length === 0) return '\"\"_';\n    return serializeContainer({\n      node: this,\n      options,\n      depth,\n      openChar: '(',\n      closeChar: ')',\n      count: this.chunks.length,\n      indefiniteLength: true,\n      encodingWidth: undefined,\n      hasEntryComments: () => this.chunks.some(hasPreservedComments),\n      renderEntry: (i) => this.chunks[i]._toCDN(options, depth + 1),\n      entryLeadingNode: (i) => this.chunks[i],\n      entryTrailing: (i, style) =>\n        formatTrailingComments(this.chunks[i], style),\n    });\n  }\n\n  override _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[] {\n    const lines: AnnotatedLine[] = [\n      {\n        depth,\n        hex: byteToHexUpper((MT_TEXT << 5) | AI_INDEFINITE),\n        comment: 'Start indefinite-length text string',\n      },\n    ];\n    for (const chunk of this.chunks)\n      lines.push(...chunk._toHexDump(depth + 1, options));\n    lines.push({ depth, hex: byteToHexUpper(BREAK_CODE), comment: '\"break\"' });\n    return lines;\n  }\n\n  _toJS(_options?: ToJSOptions): unknown {\n    return this.chunks.map((c) => c.value).join('');\n  }\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CBOR_OMIT } from '../types';\nimport { CborItem } from './CborItem';\nimport type { AnnotatedLine } from './CborItem';\nimport { MT_ARRAY, AI_INDEFINITE, BREAK_CODE } from '../cbor/constants';\nimport {\n  writeHead,\n  writeHeadTo,\n  type CborWriter,\n  type EncodingWidth,\n} from '../cbor/encode';\nimport {\n  formatTrailingComments,\n  hasPreservedComments,\n  serializeContainer,\n} from '../cdn/serialize-utils';\nimport { byteToHexUpper, bytesToSpacedHexUpper } from '../utils/hex';\n\n/** CBOR Major Type 4 — array (definite- or indefinite-length). */\nexport class CborArray extends CborItem {\n  readonly items: CborItem[];\n  readonly indefiniteLength: boolean;\n  encodingWidth: EncodingWidth | undefined;\n\n  constructor(\n    items: CborItem[],\n    options?: { indefiniteLength?: boolean; encodingWidth?: EncodingWidth }\n  ) {\n    super();\n    this.items = items;\n    this.indefiniteLength = options?.indefiniteLength ?? false;\n    this.encodingWidth = options?.encodingWidth;\n  }\n\n  override get _containsCdnContainer(): boolean {\n    return true;\n  }\n\n  override _encodeTo(writer: CborWriter, options?: ToCBOROptions): void {\n    if (this.indefiniteLength) {\n      writer.writeByte((MT_ARRAY << 5) | AI_INDEFINITE);\n      for (const item of this.items) item._encode(writer, options);\n      writer.writeByte(BREAK_CODE);\n      return;\n    }\n    writeHeadTo(writer, MT_ARRAY, this.items.length, this.encodingWidth);\n    for (const item of this.items) item._encode(writer, options);\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    return serializeContainer({\n      node: this,\n      options,\n      depth,\n      openChar: '[',\n      closeChar: ']',\n      count: this.items.length,\n      indefiniteLength: this.indefiniteLength,\n      encodingWidth: this.encodingWidth,\n      hasEntryComments: () => this.items.some(hasPreservedComments),\n      renderEntry: (i) => this.items[i]._toCDN(options, depth + 1),\n      entryIsLeaf: (i) => !this.items[i]._containsCdnContainer,\n      entryLeadingNode: (i) => this.items[i],\n      entryTrailing: (i, style) => formatTrailingComments(this.items[i], style),\n    });\n  }\n\n  override _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[] {\n    if (this.indefiniteLength) {\n      const lines: AnnotatedLine[] = [\n        {\n          depth,\n          hex: byteToHexUpper((MT_ARRAY << 5) | AI_INDEFINITE),\n          comment: 'Start indefinite-length array',\n        },\n      ];\n      for (const item of this.items)\n        lines.push(...item._toHexDump(depth + 1, options));\n      lines.push({\n        depth,\n        hex: byteToHexUpper(BREAK_CODE),\n        comment: '\"break\"',\n      });\n      return lines;\n    }\n    const lines: AnnotatedLine[] = [\n      {\n        depth,\n        hex: bytesToSpacedHexUpper(\n          writeHead(MT_ARRAY, BigInt(this.items.length), this.encodingWidth)\n        ),\n        comment: `Array of length ${this.items.length}`,\n      },\n    ];\n    for (const item of this.items)\n      lines.push(...item._toHexDump(depth + 1, options));\n    return lines;\n  }\n\n  _toJS(options?: ToJSOptions): unknown {\n    const reviver = options?.reviver;\n    if (!reviver) return this.items.map((item) => item._toJS(options));\n    // First pass: pre-populate holder with unrevived values so later siblings\n    // are still raw when earlier callbacks run (matches JSON.parse sibling timing).\n    const optNoReviver = options\n      ? { ...options, reviver: undefined }\n      : undefined;\n    const holder: unknown[] = this.items.map((item) =>\n      item._toJS(optNoReviver)\n    );\n    // Second pass: revive each element depth-first, splice out undefined entries\n    // immediately so `this` reflects the compacted in-progress array.\n    // Original indices are used as reviver keys; undefined → omit (compact,\n    // differs from JSON.parse which leaves holes).\n    let deleted = 0;\n    for (let i = 0; i < this.items.length; i++) {\n      const hIdx = i - deleted;\n      const val = this.items[i]._toJS(options);\n      const rv = reviver.call(holder, String(i), val);\n      const omit =\n        rv === CBOR_OMIT || (options?.undefinedOmits && rv === undefined);\n      if (omit) {\n        holder.splice(hIdx, 1);\n        deleted++;\n      } else {\n        holder[hIdx] = rv;\n      }\n    }\n    return holder;\n  }\n}\n","import type {\n  CborComment,\n  ToCDNOptions,\n  ToJSOptions,\n  ToCBOROptions,\n} from '../types';\nimport { CBOR_OMIT } from '../types';\nimport { MapEntries } from '../mapEntries';\nimport { CborItem } from './CborItem';\nimport type { AnnotatedLine } from './CborItem';\nimport { CborTextString } from './CborTextString';\nimport { MT_MAP, AI_INDEFINITE, BREAK_CODE } from '../cbor/constants';\nimport {\n  writeHead,\n  writeHeadTo,\n  type CborWriter,\n  type EncodingWidth,\n} from '../cbor/encode';\nimport {\n  convertCommentText,\n  hasPreservedComments,\n  serializeContainer,\n} from '../cdn/serialize-utils';\nimport { byteToHexUpper, bytesToSpacedHexUpper } from '../utils/hex';\n\n/** CBOR Major Type 5 — map (definite- or indefinite-length). */\nexport class CborMap extends CborItem {\n  readonly entries: [CborItem, CborItem][];\n  readonly indefiniteLength: boolean;\n  encodingWidth: EncodingWidth | undefined;\n\n  constructor(\n    entries: [CborItem, CborItem][],\n    options?: { indefiniteLength?: boolean; encodingWidth?: EncodingWidth }\n  ) {\n    super();\n    this.entries = entries;\n    this.indefiniteLength = options?.indefiniteLength ?? false;\n    this.encodingWidth = options?.encodingWidth;\n  }\n\n  override get _containsCdnContainer(): boolean {\n    return true;\n  }\n\n  override _encodeTo(writer: CborWriter, options?: ToCBOROptions): void {\n    if (this.indefiniteLength) {\n      writer.writeByte((MT_MAP << 5) | AI_INDEFINITE);\n      for (const [k, v] of this.entries) {\n        k._encode(writer, options);\n        v._encode(writer, options);\n      }\n      writer.writeByte(BREAK_CODE);\n      return;\n    }\n    writeHeadTo(writer, MT_MAP, this.entries.length, this.encodingWidth);\n    for (const [k, v] of this.entries) {\n      k._encode(writer, options);\n      v._encode(writer, options);\n    }\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    return serializeContainer({\n      node: this,\n      options,\n      depth,\n      openChar: '{',\n      closeChar: '}',\n      count: this.entries.length,\n      indefiniteLength: this.indefiniteLength,\n      encodingWidth: this.encodingWidth,\n      hasEntryComments: () =>\n        this.entries.some(\n          ([key, value]) =>\n            hasPreservedComments(key) || hasPreservedComments(value)\n        ),\n      renderEntry: (i, colSep) => {\n        const [k, v] = this.entries[i];\n        return `${k._toCDN(options, depth + 1)}${colSep}${v._toCDN(options, depth + 1)}`;\n      },\n      entryIsLeaf: (i) => {\n        const [k, v] = this.entries[i];\n        return !k._containsCdnContainer && !v._containsCdnContainer;\n      },\n      // Leading comments come from the key; the value's leading comments\n      // render inline after the entry (see entryTrailing).\n      entryLeadingNode: (i) => this.entries[i][0],\n      entryTrailing: (i, style) => {\n        const [k, v] = this.entries[i];\n        return formatMapEntryTrailingComments(\n          [\n            ...(k.comments?.trailing ?? []),\n            ...(v.comments?.leading ?? []),\n            ...(v.comments?.trailing ?? []),\n          ],\n          style\n        );\n      },\n    });\n  }\n\n  override _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[] {\n    if (this.indefiniteLength) {\n      const lines: AnnotatedLine[] = [\n        {\n          depth,\n          hex: byteToHexUpper((MT_MAP << 5) | AI_INDEFINITE),\n          comment: 'Start indefinite-length map',\n        },\n      ];\n      for (const [k, v] of this.entries) {\n        lines.push(...k._toHexDump(depth + 1, options));\n        lines.push(...v._toHexDump(depth + 1, options));\n      }\n      lines.push({\n        depth,\n        hex: byteToHexUpper(BREAK_CODE),\n        comment: '\"break\"',\n      });\n      return lines;\n    }\n    const lines: AnnotatedLine[] = [\n      {\n        depth,\n        hex: bytesToSpacedHexUpper(\n          writeHead(MT_MAP, BigInt(this.entries.length), this.encodingWidth)\n        ),\n        comment: `Map of length ${this.entries.length}`,\n      },\n    ];\n    for (const [k, v] of this.entries) {\n      lines.push(...k._toHexDump(depth + 1, options));\n      lines.push(...v._toHexDump(depth + 1, options));\n    }\n    return lines;\n  }\n\n  _toJS(options?: ToJSOptions): unknown {\n    const reviver = options?.reviver;\n    const toEntries = () => {\n      const result = MapEntries.from(\n        this.entries,\n        ([k, v]) => [k._toJS(options), v._toJS(options)] as [unknown, unknown]\n      );\n      if (!reviver) return result;\n      const uOmits = options?.undefinedOmits;\n      for (let i = 0; i < result.length; i++) {\n        const [k, v] = result[i];\n        const rv = reviver.call(result, k, v);\n        if (rv === CBOR_OMIT || (uOmits && rv === undefined))\n          result.splice(i--, 1);\n        else result[i] = [k, rv];\n      }\n      return result;\n    };\n    const toObject = () => {\n      // First pass: pre-populate holder with unrevived values so all sibling\n      // keys are visible in `this` when reviver runs (matches JSON.parse).\n      const optNoReviver = options\n        ? { ...options, reviver: undefined }\n        : undefined;\n      const holder: Record<string, unknown> = {};\n      for (const [k, v] of this.entries) {\n        const key = k instanceof CborTextString ? k.value : k.toCDN();\n        const raw = v._toJS(optNoReviver);\n        if (key === '__proto__') {\n          Object.defineProperty(holder, key, {\n            value: raw,\n            writable: true,\n            enumerable: true,\n            configurable: true,\n          });\n        } else {\n          holder[key] = raw;\n        }\n      }\n      if (!reviver) return holder;\n      // Second pass: process each property sequentially depth-first.\n      // Only the last occurrence of each key is revived to avoid duplicate\n      // callbacks when CBOR maps contain repeated keys.\n      const lastIdx = new Map<string, number>();\n      for (let i = 0; i < this.entries.length; i++) {\n        const [k] = this.entries[i];\n        lastIdx.set(k instanceof CborTextString ? k.value : k.toCDN(), i);\n      }\n      for (let i = 0; i < this.entries.length; i++) {\n        const [k, v] = this.entries[i];\n        const key = k instanceof CborTextString ? k.value : k.toCDN();\n        if (lastIdx.get(key) !== i) continue;\n        const val = v._toJS(options);\n        const rv = reviver.call(holder, key, val);\n        const omit =\n          rv === CBOR_OMIT || (options?.undefinedOmits && rv === undefined);\n        if (!omit) {\n          if (key === '__proto__') {\n            Object.defineProperty(holder, key, {\n              value: rv,\n              writable: true,\n              enumerable: true,\n              configurable: true,\n            });\n          } else {\n            holder[key] = rv;\n          }\n        } else {\n          delete holder[key];\n        }\n      }\n      return holder;\n    };\n\n    if (options?.mapAs === 'entries') return toEntries();\n    if (options?.mapAs === 'object') return toObject();\n    if (this.entries.every(([k]) => k instanceof CborTextString))\n      return toObject();\n    return toEntries();\n  }\n}\n\nfunction formatMapEntryTrailingComments(\n  comments: CborComment[],\n  style?: 'c-style' | 'cdn-style'\n): string {\n  if (comments.length === 0) return '';\n  return (\n    ' ' +\n    comments\n      .map((comment) => convertCommentText(comment, style).trimEnd())\n      .join(' ')\n  );\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CborItem } from './CborItem';\nimport { Simple } from '../simple';\nimport { MT_SIMPLE, AI_1BYTE } from '../cbor/constants';\nimport type { CborWriter } from '../cbor/encode';\n\n/**\n * CBOR Major Type 7 — simple value (0–255).\n *\n * Well-known values:\n *   20 → false\n *   21 → true\n *   22 → null\n *   23 → undefined\n */\nexport class CborSimple extends CborItem {\n  readonly value: number;\n  /**\n   * Original CDN digit spelling of the argument to `simple(...)` (base +\n   * digits), set by the parser when this value came from CDN text. Used by\n   * `_toCDN()` to round-trip the argument's base (`0x10`, decimal, …) when\n   * `preserveNumberFormat` is set.\n   */\n  readonly ednSource?: string;\n\n  constructor(value: number, options?: { ednSource?: string }) {\n    super();\n    if (!Number.isInteger(value) || value < 0 || value > 255)\n      throw new RangeError('CborSimple value must be an integer in 0–255');\n    this.value = value;\n    this.ednSource = options?.ednSource;\n  }\n\n  static readonly FALSE = new CborSimple(20);\n  static readonly TRUE = new CborSimple(21);\n  static readonly NULL = new CborSimple(22);\n  static readonly UNDEFINED = new CborSimple(23);\n\n  override _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void {\n    // Values 0–23: encoded in the initial byte (MT7 | value)\n    if (this.value <= 23) {\n      writer.writeByte((MT_SIMPLE << 5) | this.value);\n      return;\n    }\n    // Values 24–255: MT7, AI_1BYTE, then one value byte\n    writer.writeByte((MT_SIMPLE << 5) | AI_1BYTE);\n    writer.writeByte(this.value);\n  }\n\n  _toCDN(options: ToCDNOptions | undefined, _depth: number): string {\n    // A value written as simple(20) etc. is a different spelling choice from\n    // the false/true/null/undefined keywords, even though it denotes the\n    // same value — so preserveNumberFormat must keep simple(...) notation\n    // (checked before the keyword shortcuts below, which only apply to\n    // values that were never parsed via simple(...) in the first place).\n    if (options?.preserveNumberFormat && this.ednSource !== undefined)\n      return `simple(${this.ednSource})`;\n    switch (this.value) {\n      case 20:\n        return 'false';\n      case 21:\n        return 'true';\n      case 22:\n        return 'null';\n      case 23:\n        return 'undefined';\n      default:\n        return `simple(${this.value})`;\n    }\n  }\n\n  _toJS(_options?: ToJSOptions): unknown {\n    switch (this.value) {\n      case 20:\n        return false;\n      case 21:\n        return true;\n      case 22:\n        return null;\n      case 23:\n        return undefined;\n      default:\n        return new Simple(this.value);\n    }\n  }\n}\n","import type { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';\nimport { CborItem } from './CborItem';\nimport type { AnnotatedLine } from './CborItem';\nimport { MT_BYTES } from '../cbor/constants';\nimport {\n  writeHead,\n  writeHeadTo,\n  CborWriter,\n  type EncodingWidth,\n} from '../cbor/encode';\nimport {\n  formatTrailingComments,\n  hasPreservedComments,\n  serializeContainer,\n} from '../cdn/serialize-utils';\nimport { bytesToSpacedHexUpper } from '../utils/hex';\n\n/**\n * CBOR Sequence Literal (§2.5.6) — `<<item, item, ...>>`.\n *\n * Encodes as a definite-length byte string whose value is the concatenation\n * of the CBOR encodings of the contained items.\n *\n * @example\n * // <<1, 2>>  →  h'0102'\n * new CborEmbeddedCBOR([new CborUint(1n), new CborUint(2n)])\n */\nexport class CborEmbeddedCBOR extends CborItem {\n  readonly items: CborItem[];\n  encodingWidth: EncodingWidth | undefined;\n\n  constructor(items: CborItem[], options?: { encodingWidth?: EncodingWidth }) {\n    super();\n    this.items = items;\n    this.encodingWidth = options?.encodingWidth;\n  }\n\n  override get _containsCdnContainer(): boolean {\n    return this.items.some((item) => item._containsCdnContainer);\n  }\n\n  /** The raw concatenated CBOR bytes of all contained items. */\n  private _content(options?: ToCBOROptions): Uint8Array {\n    const inner = new CborWriter();\n    for (const item of this.items) item._encode(inner, options);\n    return inner.finish();\n  }\n\n  override _encodeTo(writer: CborWriter, options?: ToCBOROptions): void {\n    // The head needs the content's byte length, so the items are encoded\n    // into a separate buffer first.\n    const content = this._content(options);\n    writeHeadTo(writer, MT_BYTES, content.length, this.encodingWidth);\n    writer.writeBytes(content);\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    return serializeContainer({\n      node: this,\n      options,\n      depth,\n      openChar: '<<',\n      closeChar: '>>',\n      count: this.items.length,\n      indefiniteLength: false,\n      encodingWidth: this.encodingWidth,\n      eiPosition: 'close',\n      canonicalCount: () => BigInt(this._content(options).length),\n      hasEntryComments: () => this.items.some(hasPreservedComments),\n      renderEntry: (i) => this.items[i]._toCDN(options, depth + 1),\n      // entryIsLeaf is intentionally omitted (defaults to \"always a leaf\"):\n      // unlike CborArray/CborMap, an item that is itself an array/map still\n      // inlines here as long as its own rendering fits on one line — <<...>>\n      // is a flat sequence of encoded items, not a nested-structure display.\n      entryLeadingNode: (i) => this.items[i],\n      entryTrailing: (i, style) => formatTrailingComments(this.items[i], style),\n    });\n  }\n\n  override _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[] {\n    const content = this._content();\n    const n = content.length;\n    const lines: AnnotatedLine[] = [\n      {\n        depth,\n        hex: bytesToSpacedHexUpper(\n          writeHead(MT_BYTES, BigInt(n), this.encodingWidth)\n        ),\n        comment: `Embedded CBOR sequence, ${n} byte${n !== 1 ? 's' : ''}`,\n      },\n    ];\n    for (const item of this.items) {\n      lines.push(...item._toHexDump(depth + 1, options));\n    }\n    return lines;\n  }\n\n  _toJS(_options?: ToJSOptions): unknown {\n    return this._content();\n  }\n}\n","/**\n * Strip whitespace and EDN §2.2 comments from app-string content.\n *\n * Used by extensions whose content allows the same comment syntax as byte\n * string literals (b32, h32, float, …):\n *   SP / LF / CR       — whitespace, skipped\n *   # … LF             — line comment\n *   // … LF            — line comment\n *   /* … *\\/           — block comment (unterminated → SyntaxError)\n *   / … /              — block comment (unterminated → SyntaxError)\n */\nexport function stripComments(str: string): string {\n  let out = '';\n  let i = 0;\n  while (i < str.length) {\n    const ch = str[i];\n    if (ch === ' ' || ch === '\\n' || ch === '\\r') {\n      i++;\n      continue;\n    }\n    if (ch === '#') {\n      while (i < str.length && str[i] !== '\\n') i++;\n      continue;\n    }\n    if (ch === '/') {\n      const next = str[i + 1] ?? '';\n      if (next === '/') {\n        while (i < str.length && str[i] !== '\\n') i++;\n        continue;\n      }\n      if (next === '*') {\n        i += 2;\n        while (\n          i < str.length &&\n          !(str[i] === '*' && (str[i + 1] ?? '') === '/')\n        )\n          i++;\n        if (i >= str.length)\n          throw new SyntaxError('unterminated block comment');\n        i += 2; // consume */\n        continue;\n      }\n      // / … / block comment\n      i++;\n      while (i < str.length && str[i] !== '/') i++;\n      if (i >= str.length) throw new SyntaxError('unterminated block comment');\n      i++; // consume closing /\n      continue;\n    }\n    out += ch;\n    i++;\n  }\n  return out;\n}\n","import type { CborExtension } from './types';\nimport { CborByteString } from '../ast/CborByteString';\nimport { stripComments } from '../utils/strip-comments';\n\nconst B32_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';\nconst H32_ALPHA = '0123456789ABCDEFGHIJKLMNOPQRSTUV';\n\nfunction stripBase32Padding(str: string): string {\n  let end = str.length;\n  while (end > 0 && str.charCodeAt(end - 1) === 0x3d) end--;\n  return str.slice(0, end);\n}\n\nfunction base32Decode(\n  str: string,\n  alpha: string,\n  onError?: (msg: string) => void\n): Uint8Array {\n  // Padding is optional; strip it before decoding.\n  const s = stripBase32Padding(str).toUpperCase();\n  // RFC 4648 §6: valid unpadded lengths mod 8 are 0, 2, 4, 5, 7.\n  // Lengths 1, 3, 6 can never result from any valid byte sequence.\n  const rem = s.length % 8;\n  if (rem === 1 || rem === 3 || rem === 6)\n    throw new SyntaxError(`invalid base32 length: ${s.length} characters`);\n  const lookup = new Uint8Array(128).fill(0xff);\n  for (let i = 0; i < alpha.length; i++) lookup[alpha.charCodeAt(i)] = i;\n  const out = new Uint8Array(Math.floor((s.length * 5) / 8));\n  let buf = 0,\n    bufBits = 0,\n    outIdx = 0;\n  for (const ch of s) {\n    const code = ch.charCodeAt(0);\n    const val = code < 128 ? lookup[code] : 0xff;\n    if (val === 0xff)\n      throw new SyntaxError(\n        `invalid character in byte string: ${JSON.stringify(ch)}`\n      );\n    buf = (buf << 5) | val;\n    bufBits += 5;\n    if (bufBits >= 8) {\n      bufBits -= 8;\n      out[outIdx++] = (buf >> bufBits) & 0xff;\n    }\n  }\n  // RFC 4648 §3.5: trailing bits in the final quantum must be zero.\n  if (bufBits > 0 && (buf & ((1 << bufBits) - 1)) !== 0) {\n    const msg = 'non-zero trailing bits in base32 input';\n    if (onError) onError(msg);\n    else throw new SyntaxError(msg);\n  }\n  return out;\n}\n\n/** RFC 4648 §6 Base32 (A–Z 2–7) app-string extension. */\nexport const b32: CborExtension = {\n  appStringPrefixes: ['b32'],\n  parseAppString(_prefix, content, onError) {\n    return new CborByteString(\n      base32Decode(stripComments(content), B32_ALPHA, onError),\n      {\n        ednEncoding: 'base32',\n      }\n    );\n  },\n};\n\n/** RFC 4648 §7 Base32Hex (0–9 A–V) app-string extension. */\nexport const h32: CborExtension = {\n  appStringPrefixes: ['h32'],\n  parseAppString(_prefix, content, onError) {\n    return new CborByteString(\n      base32Decode(stripComments(content), H32_ALPHA, onError),\n      {\n        ednEncoding: 'base32hex',\n      }\n    );\n  },\n};\n","/**\n * Decode base64 text (classic or URL-safe alphabet, padding optional) into\n * bytes, with strict RFC 4648 validation.\n *\n * Used by the CDN parser (b64'…' literals, §5.3.4) and the CDDL tokenizer\n * (b64'…' byte strings, RFC 8610 §3.1).\n *\n * Recoverable deviations (padding-count mismatches, non-zero trailing bits)\n * are reported through `onRecoverableError` when provided; otherwise they\n * throw a plain SyntaxError, which callers wrap with position information.\n */\nexport function base64ToBytes(\n  b64: string,\n  onRecoverableError?: (msg: string) => void\n): Uint8Array {\n  // Separate data characters from trailing '=' padding.\n  const eqIdx = b64.indexOf('=');\n  const data = eqIdx >= 0 ? b64.slice(0, eqIdx) : b64;\n  const pad = eqIdx >= 0 ? b64.slice(eqIdx) : '';\n\n  // draft-25 b64dig = ALPHA / DIGIT / \"-\" / \"_\" / \"+\" / \"/\"\n  // Classic (+/) and URL-safe (-_) position-62/63 chars are both valid in the\n  // same literal. Reject anything outside this set as a hard error.\n  if (/[^A-Za-z0-9+/\\-_]/.test(data)) {\n    const bad = [...data].find((c) => !/[A-Za-z0-9+/\\-_]/.test(c)) ?? '';\n    throw new SyntaxError(\n      `invalid character ${JSON.stringify(bad)} in base64 data`\n    );\n  }\n  if (pad && !/^=+$/.test(pad))\n    throw new SyntaxError(`invalid character after base64 '=' padding`);\n\n  const rem = data.length % 4;\n\n  // rem === 1 cannot arise from any valid byte sequence (always invalid).\n  if (rem === 1)\n    throw new SyntaxError(\n      `invalid base64 length: ${data.length} data characters (length mod 4 = 1 is never valid)`\n    );\n\n  // Expected number of '=' characters for this data length.\n  const expectedPad = rem === 0 ? 0 : 4 - rem;\n\n  if (pad.length > expectedPad) {\n    const msg = `base64 has ${pad.length} '=' character${pad.length > 1 ? 's' : ''} but the data length (${data.length}) requires at most ${expectedPad}`;\n    if (onRecoverableError) onRecoverableError(msg);\n    else throw new SyntaxError(msg);\n  }\n\n  // Partial padding: some '=' present but fewer than the full required amount.\n  // draft-25 accommodates NO padding; any '=' present must be the full set.\n  if (pad.length > 0 && pad.length < expectedPad) {\n    const msg = `base64 has ${pad.length} '=' character${pad.length > 1 ? 's' : ''} but needs exactly ${expectedPad} — use full padding or no padding at all`;\n    if (onRecoverableError) onRecoverableError(msg);\n    else throw new SyntaxError(msg);\n  }\n  // Zero '=': draft-25 allows omitting padding entirely — always accepted.\n\n  // Non-zero trailing bits in the last data character (RFC 4648 §3.5).\n  // Normalize URL-safe chars first so the lookup is against the classic table.\n  // rem=2 (1-byte quantum): bottom 4 bits of the final char must be zero.\n  // rem=3 (2-byte quantum): bottom 2 bits of the final char must be zero.\n  if (rem !== 0 && data.length > 0) {\n    const ALPHA =\n      'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n    const lastChar = data[data.length - 1]!.replace('-', '+').replace('_', '/');\n    const lastVal = ALPHA.indexOf(lastChar);\n    if (lastVal >= 0) {\n      const mask = rem === 2 ? 0x0f : 0x03;\n      if ((lastVal & mask) !== 0) {\n        const msg = `base64 has non-zero trailing bits in the final quantum (RFC 4648 §3.5)`;\n        if (onRecoverableError) onRecoverableError(msg);\n        else throw new SyntaxError(msg);\n      }\n    }\n  }\n\n  // Normalize URL-safe chars to classic and add any missing padding so the\n  // underlying decoder accepts the input regardless of what was originally used.\n  const normalized =\n    data.replace(/-/g, '+').replace(/_/g, '/') + '='.repeat(expectedPad);\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if (typeof (Uint8Array as any).fromBase64 === 'function') {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (Uint8Array as any).fromBase64(normalized, {\n      alphabet: 'base64',\n      lastChunkHandling: 'loose',\n    });\n  }\n  const binary = atob(normalized);\n  const out = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);\n  return out;\n}\n","/**\n * §4.1 of draft-ietf-cbor-edn-literals-25 — Stand-in for unknown app-extensions.\n *\n * When the CDN parser encounters an unrecognised application-extension\n * identifier (the default `unresolvedExtension: 'cpa999'` behaviour), it wraps\n * the literal in a CPA999 tag instead of throwing a SyntaxError.\n *\n * Structure:\n *   CPA999([<prefix>, [<content-items...>]])\n *\n * Examples:\n *   cri'https://example.com'   → CPA999([\"cri\", [\"https://example.com\"]])\n *   hash<<\"data\", -44>>        → CPA999([\"hash\", [\"data\", -44]])\n *\n * toCDN() reconstructs the original app-string / app-sequence notation:\n *   CPA999([\"cri\", [\"https://example.com\"]]) → cri'https://example.com'\n *   CPA999([\"hash\", [\"data\", -44]])           → hash<<\"data\", -44>>\n *\n * Note: CPA999 is a provisional tag number (CPA = Code Point Allocation).\n * It will be replaced by an IANA-assigned tag number upon RFC publication.\n */\n\nimport type { ToCDNOptions } from '../types';\nimport { CborTag } from './CborTag';\nimport { CborArray } from './CborArray';\nimport { CborTextString } from './CborTextString';\nimport type { CborItem } from './CborItem';\nimport { escapeAppString } from '../cdn/serialize-utils';\n\n/** Provisional tag number for the Unresolved Application-Extension stand-in. */\nexport const CPA999_TAG = 999n;\n\n/**\n * Stand-in for an unrecognised EDN application-extension literal.\n *\n * Structure:\n *   App-string:  CPA999([prefix, text])\n *   App-sequence: CPA999([prefix, [items...]])\n */\nexport class CborUnresolvedAppExt extends CborTag {\n  constructor(prefix: string, items: CborItem[]) {\n    // App-string: single text item → tag(999, [prefix, text])\n    // App-sequence: otherwise → tag(999, [prefix, [items...]])\n    const content =\n      items.length === 1 && items[0] instanceof CborTextString\n        ? items[0]\n        : new CborArray(items);\n    super(CPA999_TAG, new CborArray([new CborTextString(prefix), content]));\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, depth);\n\n    const arr = this.content as CborArray;\n    const prefix = (arr.items[0] as CborTextString).value;\n    const contentItem = arr.items[1];\n\n    // Text string → reconstruct app-string form: prefix'content'\n    if (contentItem instanceof CborTextString) {\n      return `${prefix}${escapeAppString(contentItem.value)}`;\n    }\n\n    // Array → reconstruct app-sequence form: prefix<<item, item, ...>>\n    const contentArr = contentItem as CborArray;\n    const inner = contentArr.items\n      .map((item) => item._toCDN(options, depth))\n      .join(', ');\n    return `${prefix}<<${inner}>>`;\n  }\n}\n","import type { ToCDNOptions, ToCBOROptions, ToJSOptions } from '../types';\nimport { CborItem } from './CborItem';\nimport type { CborWriter } from '../cbor/encode';\nimport { resolveIndent } from '../cdn/serialize-utils';\n\n/**\n * Wraps a resolved app-sequence result and preserves the original EDN source\n * text for round-trip fidelity.\n *\n * In the default `encodingIndicators: 'auto'` mode, `_toCDN` returns the\n * stored source text verbatim. For `'always'` and `'never'`, it delegates to\n * the resolved item so the option is applied recursively to every data item;\n * preserving the source verbatim would leave nested indicators unchanged.\n * In single-line output (no `indent`), a source spelling that spans multiple\n * lines also delegates to the inner item, since it cannot be re-emitted\n * without breaking the single-line guarantee.\n *\n * CBOR encoding and JS conversion always delegate to the inner item so the\n * wrapper is fully transparent for those operations.\n */\nexport class CborAppSeqResult extends CborItem {\n  constructor(\n    readonly inner: CborItem,\n    readonly ednSource: string\n  ) {\n    super();\n  }\n\n  override get _containsCdnContainer(): boolean {\n    return this.inner._containsCdnContainer;\n  }\n\n  override _encodeTo(writer: CborWriter, options?: ToCBOROptions): void {\n    this.inner._encode(writer, options);\n  }\n\n  _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    const mode = options?.encodingIndicators ?? 'auto';\n    if (\n      options?.appStrings !== false &&\n      mode === 'auto' &&\n      (resolveIndent(options) !== null || !/[\\r\\n]/.test(this.ednSource))\n    )\n      return this.ednSource;\n    return this.inner._toCDN(options, depth);\n  }\n\n  _toJS(options?: ToJSOptions): unknown {\n    return this.inner._toJS(options);\n  }\n}\n","/**\n * §4.2 of draft-ietf-cbor-edn-literals-25 — Ellipsis (Elision) tag.\n *\n * Two forms:\n *   888(null)          — subtree elision:    a whole data item replaced by ...\n *   888([frag, 888(null), frag, ...])\n *                      — string/bytes elision: fragments alternating with ellipses\n *\n * Note: CPA888 is a provisional tag number.\n */\n\nimport type { ToCDNOptions } from '../types';\nimport { CborTag } from './CborTag';\nimport { CborArray } from './CborArray';\nimport { CborByteString } from './CborByteString';\nimport { CborTextString } from './CborTextString';\nimport { CborSimple } from './CborSimple';\nimport type { CborItem } from './CborItem';\nimport { bytesToHex } from '../utils/hex';\nimport {\n  escapeString,\n  resolveIndent,\n  serializeBytes,\n  stripByteLiteralComments,\n  convertCommentText,\n  danglingCommentsByGap,\n  joinConcatParts,\n  type ByteCommentSyntax,\n} from '../cdn/serialize-utils';\n\nexport const CPA888_TAG = 888n;\n\n/**\n * Comments between two top-level `items` entries (a real `+` the parser\n * never fused away — see `CborByteString.ednParts`/`CborTextString\n * .ednPartSpans` for the case where two literals *did* fuse into one node\n * with no per-part AST node of their own) land on one of them as ordinary\n * `leading`/`trailing`, exactly like any other array entry: `attachComments`\n * runs generically over the whole tree, and both entries are real\n * `CborItem`s once the parser stamps their `start`/`end`.\n */\nfunction boundaryComments(\n  prev: CborItem,\n  next: CborItem,\n  preserveComments: boolean,\n  style: 'c-style' | 'cdn-style' | undefined\n): string[] {\n  if (!preserveComments) return [];\n  return [\n    ...(prev.comments?.trailing ?? []).map((c) => convertCommentText(c, style)),\n    ...(next.comments?.leading ?? []).map((c) => convertCommentText(c, style)),\n  ];\n}\n\n/**\n * Join elision fragments with `+`. Elision is compact/single-line by\n * default — an abbreviated, inherently short summary of the underlying\n * value, not something meant to be reflowed across lines — but reflows\n * across multiple lines, one fragment per line like a real `+`\n * concatenation, when `indent` is enabled *and* there's a *mid-chain*\n * comment to preserve: a single line has nowhere to put a `#`/`//` line\n * comment sitting between two fragments (it has no way to terminate before\n * the rest of the chain), and a block comment kept inline there would be\n * indistinguishable from one actually written that way. With nothing to\n * preserve, or with `indent` disabled (nothing can safely hold a newline),\n * the whole chain still collapses onto one line and any such comment is\n * dropped — matching every other comment kind in single-line output.\n *\n * A comment trailing the *whole* chain needs none of this: it's promoted\n * onto this `CborEllipsis`'s own `comments.trailing` by the parser (see\n * `promoteEllipsisTailComments`), so the ordinary `entryTrailing`/root-\n * `toCDN()` machinery appends it after the rendered body — on the same\n * line if the body stayed single-line, which is always safe since nothing\n * else follows it there.\n */\nfunction joinElisionParts(\n  rendered: readonly string[],\n  gapComments: readonly (readonly string[])[],\n  indentStr: string | null,\n  depth: number\n): string {\n  if (indentStr === null || !gapComments.some((g) => g.length > 0)) {\n    return rendered.join(' + ');\n  }\n  return joinConcatParts(rendered, indentStr, depth, gapComments);\n}\n\n/**\n * Resolve a preserved source spelling: strip any embedded comment unless\n * `preserveComments` is set — a preserved spelling should still drop\n * comments by default, the same as an unpreserved literal re-derived from\n * its decoded value would — then, only when the (possibly stripped) result\n * is safe to re-emit verbatim, return it. It's safe when `indent` enables\n * multi-line output, or it doesn't actually contain a newline itself\n * (interior whitespace, or a surviving `#`/`//` line comment) — otherwise it\n * would break `ToCDNOptions.indent`'s single-line guarantee. Mirrors\n * `CborByteString`/`CborTextString`'s own preserved-source fallback check.\n * Returns `undefined` when `source` is `undefined`, or isn't usable.\n */\nfunction preservedSource(\n  source: string | undefined,\n  options: ToCDNOptions | undefined,\n  indentStr: string | null,\n  commentSyntax: ByteCommentSyntax | undefined\n): string | undefined {\n  if (source === undefined) return undefined;\n  const stripped =\n    options?.preserveComments || commentSyntax === undefined\n      ? source\n      : stripByteLiteralComments(source, commentSyntax);\n  return isSafeForCurrentMode(stripped, indentStr) ? stripped : undefined;\n}\n\n/**\n * Like `preservedSource`, but for a text source (`CborTextString`'s\n * `ednPartSources`) — text literals have no embedded-comment notation to\n * strip (a `#`/`//` there is just literal text content), so this only\n * applies the single-line safety check.\n */\nfunction usableTextSource(\n  source: string | undefined,\n  indentStr: string | null\n): source is string {\n  return source !== undefined && isSafeForCurrentMode(source, indentStr);\n}\n\nfunction isSafeForCurrentMode(\n  source: string,\n  indentStr: string | null\n): boolean {\n  return indentStr !== null || !/[\\r\\n]/.test(source);\n}\n\nexport class CborEllipsis extends CborTag {\n  /**\n   * For the array (string/bytes elision) form: `realBoundary[i]` is `true`\n   * when a genuine `+` from the source precedes `items[i]` — as opposed to\n   * `items[i]` sitting *inside* a single `h'xx...yy'` literal's own `...`\n   * notation (index 0's value is never consulted — there is nothing before\n   * the first item). `preserveConcatenation` uses this to show only the\n   * real boundaries and fuse everything else, exactly as each source\n   * literal was spelled.\n   *\n   * `undefined` means no boundary information is available at all (e.g.\n   * reconstructed from raw CBOR bytes, which carry no notion of \"was there\n   * a `+` here\" to begin with) — `preserveConcatenation` then has no effect,\n   * the same as for a value that didn't originate from CDN source.\n   */\n  readonly realBoundary: readonly boolean[] | undefined;\n\n  /**\n   * For a subtree-elision placeholder (`888(null)`, i.e. `content\n   * instanceof CborSimple`) that sits *inside* another `CborEllipsis`'s\n   * items: `true` when it came from a `h'xx...yy'`-family literal's own\n   * `...` notation — even a fully-elided `h'...'` with no hex digits at all\n   * — as opposed to a bare standalone `...` token. Only consulted when this\n   * placeholder ends up isolated as its own preserved fragment (nothing to\n   * fuse it with on either side), to pick the right spelling: `h'...'` vs\n   * plain `...`.\n   */\n  readonly fromByteLiteral: boolean;\n\n  /**\n   * When `fromByteLiteral` is `true`: that `h'xx...yy'`-family literal's own\n   * raw source text (e.g. `h'AB...CD'` verbatim — case, interior whitespace,\n   * and any `/ ... /`/`# ...` comments included), for `preserveByteString`\n   * to round-trip instead of re-emitting a freshly lower-cased, comment-free\n   * `h'...'` literal. `undefined` when `fromByteLiteral` is `false`.\n   */\n  readonly literalSource: string | undefined;\n\n  /** Subtree elision: 888(null) */\n  constructor(fromByteLiteral?: boolean, literalSource?: string);\n  /** String/bytes elision: 888([items...]) */\n  constructor(items: CborItem[], realBoundary?: readonly boolean[]);\n  constructor(\n    itemsOrFromByteLiteral?: CborItem[] | boolean,\n    realBoundaryOrLiteralSource?: readonly boolean[] | string\n  ) {\n    if (Array.isArray(itemsOrFromByteLiteral)) {\n      super(CPA888_TAG, new CborArray(itemsOrFromByteLiteral));\n      this.fromByteLiteral = false;\n      this.literalSource = undefined;\n      this.realBoundary = realBoundaryOrLiteralSource as\n        readonly boolean[] | undefined;\n    } else {\n      super(CPA888_TAG, CborSimple.NULL);\n      this.fromByteLiteral = itemsOrFromByteLiteral ?? false;\n      this.literalSource = realBoundaryOrLiteralSource as string | undefined;\n      this.realBoundary = undefined;\n    }\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, depth);\n    if (this.content instanceof CborSimple) {\n      // Subtree elision → \"...\"\n      return '...';\n    }\n    if (this.content instanceof CborArray) {\n      const preserveConcat = !!options?.preserveConcatenation;\n      if (\n        preserveConcat ||\n        (options?.preserveByteString && !this._hasRealConcatenation())\n      ) {\n        // Show only the real `+` boundaries, fusing everything else exactly\n        // as each source literal (e.g. a `h'xx...yy'`, however its own\n        // `...` is positioned) was spelled — see `realBoundary`. With no\n        // real boundary at all, this is just the one literal's own spelling.\n        const preserved = this._renderPreservedBytesElision(options, depth);\n        if (preserved !== undefined) return preserved;\n      }\n      if (!preserveConcat || this.realBoundary === undefined) {\n        // Bytes elision where every fragment is a plain byte string: re-emit\n        // the compact `h'xx...yy'` literal — the actual CDN grammar for this\n        // (§4.2) — instead of expanding it into `h'xx' + ... + h'yy'`. Always\n        // hex, regardless of `bstrEncoding`/`sqstr`: `h'...'` is the only\n        // elidable literal form: there is no elided base64 or sqstr spelling.\n        // Also the fallback when `preserveConcatenation` is set but there is\n        // no boundary information to preserve in the first place.\n        const compactHex = this._compactHexElided();\n        if (compactHex !== undefined) return compactHex;\n      }\n      // Otherwise (text elision, or bytes elision mixed with something\n      // else): frag + ... + frag, single-line unless a comment needs the\n      // extra room — see `joinElisionParts`.\n      const items = this.content.items;\n      const parts = items.map((item) =>\n        preserveConcat\n          ? this._renderFragment(item, options, depth)\n          : item._toCDN(options, depth)\n      );\n      const preserveComments = !!options?.preserveComments;\n      const style =\n        typeof options?.preserveComments === 'string'\n          ? options.preserveComments\n          : undefined;\n      const gapComments = items\n        .slice(1)\n        .map((item, i) =>\n          boundaryComments(items[i]!, item, preserveComments, style)\n        );\n      return joinElisionParts(\n        parts,\n        gapComments,\n        resolveIndent(options),\n        depth\n      );\n    }\n    return super._toCDN(options, depth);\n  }\n\n  /**\n   * `true` when this bytes elision has at least one real `+` boundary\n   * somewhere — as opposed to being a single `h'xx...yy'` literal's own\n   * `...` notation, which is not \"produced by + concatenation\" (see\n   * `preserveByteString`'s own docs) and so has its spelling preserved by\n   * `preserveByteString` alone, the same as a non-elided `h'...'` literal.\n   *\n   * A real boundary can hide two ways: as `realBoundary[i]` (`i > 0`) on the\n   * items array itself, or *inside* a merged `CborByteString` whose\n   * `ednParts.length > 1` — two `+`-joined literals that sat next to each\n   * other with no ellipsis between them (e.g. `h'AB' + h'CD...EF'`) merge\n   * into one item during parsing, so their boundary doesn't show up in\n   * `realBoundary` at that item's own index.\n   */\n  private _hasRealConcatenation(): boolean {\n    if (this.realBoundary?.some((real, i) => i > 0 && real)) return true;\n    const items = (this.content as CborArray).items;\n    return items.some(\n      (item) =>\n        item instanceof CborByteString &&\n        item.ednParts !== undefined &&\n        item.ednParts.length > 1\n    );\n  }\n\n  /**\n   * Render one elision fragment as it should appear under\n   * `preserveConcatenation`: a merged multi-part `CborTextString` (see the\n   * parser's `currentParts` consolidation) is expanded back into its\n   * original `+`-joined literals, single-line, honoring `preserveRawString`\n   * per part. Anything else (a single-part fragment, or a nested\n   * `CborEllipsis`) renders normally.\n   *\n   * Only reached for text elision (or anything not shaped like a pure bytes\n   * elision, or a bytes elision with no `realBoundary` information) —\n   * `_renderPreservedBytesElision` handles the bytes case that has that\n   * information, since it needs to see all the fragments together to know\n   * which `...`s are real `+`-joined ellipses and which are internal to one\n   * `h'...'` literal.\n   */\n  private _renderFragment(\n    item: CborItem,\n    options: ToCDNOptions | undefined,\n    depth: number\n  ): string {\n    const indentStr = resolveIndent(options);\n    const preserveComments = !!options?.preserveComments;\n    const style =\n      typeof options?.preserveComments === 'string'\n        ? options.preserveComments\n        : undefined;\n    if (\n      item instanceof CborByteString &&\n      item.ednParts !== undefined &&\n      item.ednParts.length > 1\n    ) {\n      const encoding =\n        options?.appStrings === false\n          ? 'hex'\n          : (options?.bstrEncoding ?? item.ednEncoding);\n      const literals = item.ednParts.map((part) => {\n        const source = options?.preserveByteString\n          ? preservedSource(part.source, options, indentStr, part.commentSyntax)\n          : undefined;\n        return source !== undefined\n          ? source\n          : serializeBytes(part.bytes, encoding, options?.sqstr);\n      });\n      // These parts merged into one `CborByteString` with no per-part AST\n      // node of their own — see `_renderPreservedBytesElision`'s equivalent\n      // comment — so a comment between two of them landed as `dangling` on\n      // `item` as a whole instead.\n      const internalGaps = preserveComments\n        ? (danglingCommentsByGap(\n            item.comments?.dangling,\n            item.ednParts,\n            style\n          ) ?? [])\n        : [];\n      return joinElisionParts(literals, internalGaps, indentStr, depth);\n    }\n    if (\n      item instanceof CborTextString &&\n      item.ednParts !== undefined &&\n      item.ednParts.length > 1\n    ) {\n      const partSources = options?.preserveRawString\n        ? item.ednPartSources\n        : undefined;\n      const literals = item.ednParts.map((text, i) => {\n        const source = partSources?.[i];\n        return usableTextSource(source, indentStr)\n          ? source\n          : escapeString(text);\n      });\n      const internalGaps = preserveComments\n        ? (danglingCommentsByGap(\n            item.comments?.dangling,\n            item.ednPartSpans,\n            style\n          ) ?? [])\n        : [];\n      return joinElisionParts(literals, internalGaps, indentStr, depth);\n    }\n    return item._toCDN(options, depth);\n  }\n\n  /**\n   * Re-emit a `888([...])` bytes elision as a single `h'xx...yy'` literal\n   * when every item is either a plain `CborByteString` fragment or a\n   * subtree-elision placeholder (`888(null)`) — i.e. exactly what\n   * `h'xx...yy'` parses into. Returns `undefined` when the items don't\n   * match that shape (e.g. text-string elision, or a fragment that isn't a\n   * plain byte string), so the caller falls back to the `frag + ... + frag`\n   * form.\n   */\n  private _compactHexElided(): string | undefined {\n    const items = (this.content as CborArray).items;\n    let hex = '';\n    let hasByteFragment = false;\n    for (const item of items) {\n      if (item instanceof CborByteString) {\n        hex += bytesToHex(item.value);\n        hasByteFragment = true;\n      } else if (\n        item instanceof CborEllipsis &&\n        item.content instanceof CborSimple\n      ) {\n        hex += '...';\n      } else {\n        return undefined;\n      }\n    }\n    // Without an actual byte fragment (e.g. the single-item `888([888(null)])`\n    // form), there's nothing bytes-specific to show; fall back to the plain\n    // `frag + ... + frag` path, which collapses a lone item to just `...`.\n    if (!hasByteFragment) return undefined;\n    return `h'${hex}'`;\n  }\n\n  /**\n   * `preserveConcatenation` rendering for a bytes elision. Groups the\n   * fragments at every *real* boundary (`realBoundary[i]`) and renders each\n   * group as one unit — fusing together whatever sits between real\n   * boundaries, including any `h'xx...yy'` literal's own internal `...`\n   * (wherever it's positioned — leading, trailing, or in the middle) and\n   * the fragments on either side of it, exactly as that literal was\n   * written. Within a group, a `CborByteString` that itself merged several\n   * `+`-joined literals (`ednParts.length > 1`, always a real boundary\n   * internally — see the parser) is further split at each of those parts.\n   *\n   * Returns `undefined` when there's no `realBoundary` to work from, or an\n   * item isn't a plain `CborByteString` or subtree-elision placeholder\n   * (e.g. text elision), so the caller falls back to the compact literal or\n   * the simpler per-fragment `frag + ... + frag` rendering.\n   */\n  private _renderPreservedBytesElision(\n    options: ToCDNOptions | undefined,\n    depth: number\n  ): string | undefined {\n    if (this.realBoundary === undefined) return undefined;\n    const boundary = this.realBoundary;\n    const items = (this.content as CborArray).items;\n\n    type Segment =\n      | {\n          bytes: Uint8Array;\n          source?: string;\n          commentSyntax?: ByteCommentSyntax;\n        }\n      | { ellipsis: true; fromByteLiteral: boolean; literalSource?: string };\n    const groups: Segment[][] = [];\n    // `gapComments[i]` holds already-converted comment text that sat\n    // between `groups[i]` and `groups[i + 1]` in the source. Every\n    // `flush(comments)` call happens exactly at such a gap — `current`\n    // (about to become `groups[gapComments.length]`) is whatever came\n    // *before* the gap, and whatever gets pushed to `current` right after\n    // this call is what comes *after* it — so each call always records one\n    // entry, except the final, argument-less flush at the very end of the\n    // method (nothing follows the last group).\n    const gapComments: string[][] = [];\n    let current: Segment[] = [];\n    const flush = (comments?: string[]) => {\n      if (current.length > 0) {\n        groups.push(current);\n        gapComments.push(comments ?? []);\n        current = [];\n      }\n    };\n\n    const preserveComments = !!options?.preserveComments;\n    const style =\n      typeof options?.preserveComments === 'string'\n        ? options.preserveComments\n        : undefined;\n\n    for (let i = 0; i < items.length; i++) {\n      const item = items[i]!;\n      if (i > 0 && boundary[i])\n        flush(boundaryComments(items[i - 1]!, item, preserveComments, style));\n      if (item instanceof CborEllipsis && item.content instanceof CborSimple) {\n        current.push({\n          ellipsis: true,\n          fromByteLiteral: item.fromByteLiteral,\n          literalSource: item.literalSource,\n        });\n      } else if (item instanceof CborByteString) {\n        if (item.ednParts !== undefined && item.ednParts.length > 1) {\n          const [firstPart, ...restParts] = item.ednParts;\n          current.push({\n            bytes: firstPart.bytes,\n            source: firstPart.source,\n            commentSyntax: firstPart.commentSyntax,\n          });\n          // These parts merged into one `CborByteString` with no per-part\n          // AST node of their own (no ellipsis sat between them — see\n          // `CborEllipsis._hasRealConcatenation`'s doc), so a comment\n          // between two of them landed as `dangling` on `item` as a whole\n          // instead; re-derive which internal gap each one belongs to.\n          const internalGaps = preserveComments\n            ? danglingCommentsByGap(\n                item.comments?.dangling,\n                item.ednParts,\n                style\n              )\n            : undefined;\n          restParts.forEach((part, j) => {\n            flush(internalGaps?.[j]);\n            current.push({\n              bytes: part.bytes,\n              source: part.source,\n              commentSyntax: part.commentSyntax,\n            });\n          });\n        } else {\n          current.push({\n            bytes: item.value,\n            source: item.ednSource,\n            commentSyntax: item.ednCommentSyntax,\n          });\n        }\n      } else {\n        return undefined;\n      }\n    }\n    // The closing flush has no gap after it, so it bypasses `flush()`'s own\n    // comment recording — pushing directly keeps `gapComments.length` at\n    // exactly `groups.length - 1`.\n    if (current.length > 0) groups.push(current);\n    if (groups.length === 0) return undefined;\n\n    const encoding =\n      options?.appStrings === false ? 'hex' : (options?.bstrEncoding ?? 'hex');\n    // A preserved source spelling can itself contain embedded newlines\n    // (interior whitespace, or a surviving `#`/`//` line comment) — those\n    // are only safe to re-emit verbatim when `indent` enables multi-line\n    // output; see `preservedSource`. Otherwise fall back to freshly\n    // re-serializing the bytes.\n    const indentStr = resolveIndent(options);\n    const rendered = groups.map((group) => {\n      // A group with more than one segment, or a single ellipsis-only\n      // group, always came from exactly one `h'xx...yy'` literal (see the\n      // parser: nothing but that literal's own atoms ever ends up fused\n      // together) — so any ellipsis segment's `literalSource` is that\n      // whole group's original spelling.\n      if (options?.preserveByteString) {\n        for (const s of group) {\n          if (!('ellipsis' in s)) continue;\n          // Always came from a BYTES_HEX_ELIDED token (see `_elidedHexAtoms`),\n          // so its comment syntax is unconditionally hex's full syntax.\n          const literalSource = preservedSource(\n            s.literalSource,\n            options,\n            indentStr,\n            'full'\n          );\n          if (literalSource !== undefined) return literalSource;\n        }\n      }\n      const byteSegments = group.filter(\n        (\n          s\n        ): s is {\n          bytes: Uint8Array;\n          source?: string;\n          commentSyntax?: ByteCommentSyntax;\n        } => !('ellipsis' in s)\n      );\n      if (byteSegments.length === 0) {\n        // Isolated ellipsis-only group with no preserved source: bare\n        // `...` for a genuine standalone ellipsis token, `h'...'` when it\n        // came from an elided-hex literal (even an entirely-elided one)\n        // to keep its byte-typed spelling.\n        const fromByteLiteral = group.some(\n          (s) => 'ellipsis' in s && s.fromByteLiteral\n        );\n        return fromByteLiteral ? \"h'...'\" : '...';\n      }\n      if (group.length === 1) {\n        const segment = byteSegments[0];\n        const source = options?.preserveByteString\n          ? preservedSource(\n              segment.source,\n              options,\n              indentStr,\n              segment.commentSyntax\n            )\n          : undefined;\n        return source !== undefined\n          ? source\n          : serializeBytes(segment.bytes, encoding, options?.sqstr);\n      }\n      const hex = group\n        .map((s) => ('ellipsis' in s ? '...' : bytesToHex(s.bytes)))\n        .join('');\n      return `h'${hex}'`;\n    });\n    return joinElisionParts(rendered, gapComments, indentStr, depth);\n  }\n}\n","/**\n * CBOR bignum tags (RFC 8949 §3.4.3).\n *\n *   Tag 2 — unsigned bignum: tag(2, bstr) where bstr is the big-endian\n *            encoding of a non-negative integer.\n *   Tag 3 — negative bignum: tag(3, bstr) where the value = -1 - unsigned(bstr).\n *\n * These classes are used for integers that fall outside the uint64 / nint64\n * range of CBOR major types 0 and 1:\n *   CborBigUint  — value ≥ 2^64\n *   CborBigNint  — value ≤ -(2^64 + 1)\n *\n * toCDN() emits the plain decimal form (e.g. \"18446744073709551616\") so that\n * round-trips through EDN text are human-readable.\n */\n\nimport type { ToCDNOptions, ToJSOptions } from '../types';\nimport { CborTag } from './CborTag';\nimport { CborByteString } from './CborByteString';\n\nexport const BIGNUM_UINT_TAG = 2n;\nexport const BIGNUM_NINT_TAG = 3n;\n\nconst UINT64_MAX = 0xffff_ffff_ffff_ffffn;\nconst NINT64_MIN = -(UINT64_MAX + 1n); // -18446744073709551616n\n\n// ─── Bigint ↔ bytes helpers ───────────────────────────────────────────────────\n\n/**\n * Encode a non-negative bigint as a minimal big-endian byte string.\n * Zero is encoded as the empty byte string per RFC 8949 §3.4.3.\n */\nexport function bigintToBytes(n: bigint): Uint8Array {\n  if (n < 0n)\n    throw new RangeError('bigintToBytes requires a non-negative value');\n  if (n === 0n) return new Uint8Array(0);\n  let hex = n.toString(16);\n  if (hex.length % 2 !== 0) hex = '0' + hex;\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < bytes.length; i++)\n    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);\n  return bytes;\n}\n\n/**\n * Decode a big-endian byte string to a non-negative bigint.\n * Empty bytes → 0n.\n */\nexport function bytesToBigint(bytes: Uint8Array): bigint {\n  let n = 0n;\n  for (const b of bytes) n = (n << 8n) | BigInt(b);\n  return n;\n}\n\n// ─── AST nodes ────────────────────────────────────────────────────────────────\n\n/**\n * Unsigned bignum — integers ≥ 2^64.\n * Wire format: tag(2, big-endian byte string).\n * toCDN() emits the plain decimal integer.\n */\nexport class CborBigUint extends CborTag {\n  readonly bigValue: bigint;\n\n  constructor(value: bigint) {\n    if (value <= UINT64_MAX)\n      throw new RangeError(\n        `CborBigUint value ${value} fits in CborUint; use CborUint instead`\n      );\n    super(BIGNUM_UINT_TAG, new CborByteString(bigintToBytes(value)));\n    this.bigValue = value;\n  }\n\n  override _toCDN(_options: ToCDNOptions | undefined, _depth: number): string {\n    return this.bigValue.toString();\n  }\n\n  override _toJS(_options?: ToJSOptions): bigint {\n    return this.bigValue;\n  }\n}\n\n/**\n * Negative bignum — integers ≤ -(2^64 + 1).\n * Wire format: tag(3, big-endian byte string of (-1 - value)).\n * toCDN() emits the plain decimal integer.\n */\nexport class CborBigNint extends CborTag {\n  readonly bigValue: bigint;\n\n  constructor(value: bigint) {\n    if (value >= NINT64_MIN)\n      throw new RangeError(\n        `CborBigNint value ${value} fits in CborNint; use CborNint instead`\n      );\n    super(BIGNUM_NINT_TAG, new CborByteString(bigintToBytes(-1n - value)));\n    this.bigValue = value;\n  }\n\n  override _toCDN(_options: ToCDNOptions | undefined, _depth: number): string {\n    return this.bigValue.toString();\n  }\n\n  override _toJS(_options?: ToJSOptions): bigint {\n    return this.bigValue;\n  }\n}\n","import {\n  Tokenizer,\n  type EdnComment,\n  type SqstrToken,\n  type Token,\n  type TokenType,\n} from './tokenizer';\nimport { CdnSyntaxError } from './errors';\nimport type {\n  AppSeqEncodingEdit,\n  AppSeqSourceFeatures,\n  CborItem,\n} from '../ast/CborItem';\nimport type {\n  CborComment,\n  FromCDNOptions,\n  CborExtension,\n  ParseWarning,\n} from '../types';\nimport { CborUint } from '../ast/CborUint';\nimport { CborNint } from '../ast/CborNint';\nimport { CborByteString } from '../ast/CborByteString';\nimport { CborIndefiniteByteString } from '../ast/CborIndefiniteByteString';\nimport { CborTextString } from '../ast/CborTextString';\nimport { CborIndefiniteTextString } from '../ast/CborIndefiniteTextString';\nimport { CborArray } from '../ast/CborArray';\nimport { CborMap } from '../ast/CborMap';\nimport { CborTag } from '../ast/CborTag';\nimport { CborFloat, type FloatPrecision } from '../ast/CborFloat';\nimport { CborSimple } from '../ast/CborSimple';\nimport { CborEmbeddedCBOR } from '../ast/CborEmbeddedCBOR';\nimport {\n  autoSelectFloatPrecision,\n  maxForEncodingWidth,\n  type EncodingWidth,\n} from '../cbor/encode';\nimport {\n  canonicalEncodingWidth,\n  type ByteCommentSyntax,\n} from './serialize-utils';\nimport { b32, h32 } from '../extensions/b32';\nimport { parseHexFloat } from '../utils/hexfloat';\nimport { hexToBytes } from '../utils/hex';\nimport { base64ToBytes } from '../utils/base64';\nimport { float64ToFloat16Bits, float16BitsToFloat64 } from '../utils/float16';\nimport { resolveBuiltinExtensions } from '../extensions/builtins';\nimport { CborUnresolvedAppExt } from '../ast/CborUnresolvedAppExt';\nimport { CborAppSeqResult } from '../ast/CborAppSeqResult';\nimport { CborEllipsis } from '../ast/CborEllipsis';\nimport { CborBigUint, CborBigNint } from '../ast/CborBignum';\n\n// Shared codec instances — constructing TextEncoder/TextDecoder per call is\n// measurably expensive in hot parsing paths.\nconst textEncoder = new TextEncoder();\nconst utf8Strict = new TextDecoder('utf-8', { fatal: true });\nconst utf8Lenient = new TextDecoder('utf-8', { fatal: false });\n\n// ─── Public entry point ───────────────────────────────────────────────────────\n\n/**\n * Parse a CDN text string into a CborItem AST node.\n * Throws SyntaxError on invalid input.\n */\nexport function parseCDN(text: string, options?: FromCDNOptions): CborItem {\n  const tokenizer = new Tokenizer(text, {\n    offset: options?.offset,\n    skipRS: (options as (FromCDNOptions & { _skipRS?: boolean }) | undefined)\n      ?._skipRS,\n  });\n  const parser = new CDNParser(tokenizer, options ?? {});\n  const node = parser.parse();\n  if (options?.preserveComments || options?.preserveAll) {\n    attachComments(node, tokenizer.comments, text);\n    promoteEllipsisTailComments(node);\n  }\n  return node;\n}\n\n// ─── Value helpers ────────────────────────────────────────────────────────────\n\n/** Strip an optional _0/_1/_2/_3/_i encoding-indicator suffix from a raw\n *  integer token value and return both the numeric string and the width. */\nfunction parseIntegerRaw(raw: string): {\n  numStr: string;\n  rawSuffix: string | undefined;\n} {\n  let numStr = raw;\n  let rawSuffix: string | undefined;\n  if (/[_][0-7i]$/.test(raw)) {\n    rawSuffix = raw[raw.length - 1]!;\n    numStr = raw.slice(0, -2);\n  }\n  return { numStr, rawSuffix };\n}\n\nfunction parseBigInt(raw: string): bigint {\n  if (raw.startsWith('-')) return -BigInt(raw.slice(1));\n  return BigInt(raw);\n}\n\n/**\n * `item`'s own literal-preservation features, combined with those of\n * whatever it structurally contains.\n *\n * A node can carry `appSeqSourceFeatures` on itself — set when it is *also*\n * the result of parsing a `prefix<<item>>` / `prefix'...'` source, recording\n * features of *that* inner item (see the `appSeqSourceFeatures` field on\n * `CborItem`) — independently of whatever `structuralAppSeqSourceFeatures`\n * finds by walking its children. Both must be combined: a nested extension\n * result (e.g. a `dt<<b64'...'>>` that resolved to a plain epoch number, so\n * `structuralAppSeqSourceFeatures` finds nothing byte-string-like in it\n * structurally) still carries its own inner byte-string literal's features\n * on itself, and an explicitly disabled sibling `preserve*` option must see\n * that when this node is nested inside an outer `preserveAppSequence`\n * raw-tag/`<<...>>` source (e.g. `ip`'s array content).\n */\nfunction appSeqSourceFeatures(\n  item: CborItem | undefined\n): AppSeqSourceFeatures | undefined {\n  if (item === undefined) return undefined;\n  return combineAppSeqSourceFeatures([\n    item.appSeqSourceFeatures,\n    structuralAppSeqSourceFeatures(item),\n  ]);\n}\n\nfunction structuralAppSeqSourceFeatures(\n  item: CborItem\n): AppSeqSourceFeatures | undefined {\n  if (item instanceof CborByteString) {\n    return {\n      byteString: true,\n      concatenation: item.ednParts !== undefined && item.ednParts.length > 1,\n    };\n  }\n  if (item instanceof CborTextString) {\n    const hasParts = item.ednParts !== undefined;\n    const rawPartCount =\n      item.ednPartSources?.filter((source) => source !== undefined).length ?? 0;\n    // A part with no preserved raw source is ambiguous by itself — it could\n    // be an unpreservable double-quoted literal (textString) or a\n    // byte-string literal decoded to text per §5.1 (byteString); only\n    // ednPartIsByteString distinguishes them.\n    const byteStringPartCount = hasParts\n      ? item.ednParts!.reduce((count, _text, i) => {\n          const hasSource = item.ednPartSources?.[i] !== undefined;\n          const isByteString = item.ednPartIsByteString?.[i] ?? false;\n          return hasSource || !isByteString ? count : count + 1;\n        }, 0)\n      : 0;\n    const unpreservedTextPartCount =\n      (hasParts ? item.ednParts!.length : 0) -\n      rawPartCount -\n      byteStringPartCount;\n    return {\n      byteString: byteStringPartCount > 0,\n      textString:\n        item.quotedEdnSource !== undefined || unpreservedTextPartCount > 0,\n      rawString: item.ednSource !== undefined || rawPartCount > 0,\n      concatenation: hasParts && item.ednParts!.length > 1,\n    };\n  }\n  if (item instanceof CborArray) {\n    return combineAppSeqSourceFeatures(item.items.map(appSeqSourceFeatures));\n  }\n  if (item instanceof CborMap) {\n    // ip accepts an arbitrary CborArray as tag content, so a nested map's\n    // own byte-string/text-string/concatenation literals must also be\n    // detected — otherwise an explicitly disabled sibling `preserve*`\n    // option silently has no effect on them (see collectContentEncodingEdits,\n    // which has the analogous \"unsupported nested node\" concern for\n    // encoding-indicator edits).\n    return combineAppSeqSourceFeatures(\n      item.entries.flatMap(([k, v]) => [\n        appSeqSourceFeatures(k),\n        appSeqSourceFeatures(v),\n      ])\n    );\n  }\n  if (item instanceof CborTag) return appSeqSourceFeatures(item.content);\n  if (\n    item instanceof CborIndefiniteByteString ||\n    item instanceof CborIndefiniteTextString ||\n    item instanceof CborEmbeddedCBOR\n  ) {\n    const children: CborItem[] =\n      item instanceof CborEmbeddedCBOR ? item.items : item.chunks;\n    return combineAppSeqSourceFeatures(children.map(appSeqSourceFeatures));\n  }\n  return undefined;\n}\n\nfunction combineAppSeqSourceFeatures(\n  values: (AppSeqSourceFeatures | undefined)[]\n): AppSeqSourceFeatures | undefined {\n  const features = values.filter((value) => value !== undefined);\n  if (features.length === 0) return undefined;\n  return {\n    byteString: features.some((value) => value.byteString),\n    textString: features.some((value) => value.textString),\n    rawString: features.some((value) => value.rawString),\n    concatenation: features.some((value) => value.concatenation),\n  };\n}\n\nfunction parseFloatToken(\n  raw: string,\n  onRecoverableError?: (msg: string) => void\n): {\n  value: number;\n  precision: FloatPrecision | undefined;\n} {\n  // Strip any invalid encoding indicator first, before NaN/Infinity checks,\n  // so that e.g. \"NaN_7\" still resolves to NaN after the suffix is removed.\n  if (raw.endsWith('_i') || raw.endsWith('_0')) {\n    const msg =\n      '_0 and _i encoding indicators are not valid for floating-point values';\n    if (onRecoverableError) {\n      onRecoverableError(msg);\n      raw = raw.slice(0, -2);\n    } else {\n      throw new SyntaxError(`EDN parse error: ${msg}`);\n    }\n  } else if (/[_][4567]$/.test(raw)) {\n    const suffix = raw[raw.length - 1]!;\n    const msg =\n      suffix === '7'\n        ? 'indefinite-length encoding (_7) is not valid for floating-point values'\n        : `encoding indicator _${suffix} (AI ${Number(suffix) + 24}) is reserved and not valid`;\n    if (onRecoverableError) {\n      onRecoverableError(msg);\n      raw = raw.slice(0, -2);\n    } else {\n      throw new SyntaxError(`EDN parse error: ${msg}`);\n    }\n  }\n\n  if (raw === 'NaN') return { value: NaN, precision: undefined };\n  if (raw === 'Infinity') return { value: Infinity, precision: undefined };\n  if (raw === '-Infinity') return { value: -Infinity, precision: undefined };\n\n  let numStr = raw;\n  let precision: FloatPrecision | undefined;\n  if (raw.endsWith('_1')) {\n    precision = 'half';\n    numStr = raw.slice(0, -2);\n  } else if (raw.endsWith('_2')) {\n    precision = 'single';\n    numStr = raw.slice(0, -2);\n  } else if (raw.endsWith('_3')) {\n    precision = 'double';\n    numStr = raw.slice(0, -2);\n  }\n\n  // Hex float literal: 0x[hex]p[exp] or -0x[hex]p[exp]\n  if (/^-?0[xX]/.test(numStr))\n    return { value: parseHexFloat(numStr), precision };\n\n  return { value: parseFloat(numStr), precision };\n}\n\n// ─── Blank-line tracking ─────────────────────────────────────────────────────\n\n/**\n * A blank line is a line containing only whitespace between two other lines\n * — i.e. two newlines with nothing but horizontal whitespace between them.\n * Applied to the raw gap between one container entry and the next\n * (comments and all), so a blank line is detected regardless of whether it\n * sits before, after, or inside a leading comment block.\n */\nconst BLANK_LINE_RE = /\\r?\\n[ \\t]*\\r?\\n/;\n\nfunction hasBlankLineBetween(\n  text: string,\n  start: number,\n  end: number\n): boolean {\n  return BLANK_LINE_RE.test(text.slice(start, end));\n}\n\n// ─── Comment attachment ──────────────────────────────────────────────────────\n\ninterface NodeInfo {\n  node: CborItem;\n  start: number;\n  end: number;\n}\n\nfunction relativeComments(\n  comments: readonly EdnComment[],\n  fromIndex: number,\n  start: number,\n  end: number\n): CborComment[] {\n  const result: CborComment[] = [];\n  for (let i = fromIndex; i < comments.length; i++) {\n    const comment = comments[i]!;\n    if (comment.start >= end) break;\n    if (comment.start >= start && comment.end <= end)\n      result.push({\n        ...comment,\n        start: comment.start - start,\n        end: comment.end - start,\n      });\n  }\n  return result;\n}\n\nfunction sourceSuffixEdit(\n  source: string,\n  sourceStart: number,\n  node: CborItem,\n  always: string\n): AppSeqEncodingEdit | undefined {\n  if (node.end === undefined) return undefined;\n  const hasIndicator = /_[0-7i]$/.test(\n    source.slice(Math.max(0, node.end - 2), node.end)\n  );\n  const start = (hasIndicator ? node.end - 2 : node.end) - sourceStart;\n  return {\n    start,\n    end: node.end - sourceStart,\n    always,\n    never: '',\n  };\n}\n\n/**\n * Collect source-span edits for every encoding indicator nested inside a\n * raw-tag's content, for `adjustRawAppSeqSource`.\n *\n * Returns `undefined` — instead of a partial edit list — when `node` (or\n * anything nested inside it) is a type this function doesn't know how to\n * produce an edit for (e.g. `CborMap`, `CborTag`, `CborSimple`, an\n * indefinite-length string). A partial list would silently leave that\n * node's own indicator un-edited under `encodingIndicators: 'always'` /\n * `'never'`; the caller must fall back to structural re-serialization\n * instead so every nested indicator is actually applied. `ip` accepts an\n * arbitrary `CborArray` as tag content, so this bails out for any element\n * type beyond the ones explicitly handled below rather than assuming\n * coverage is complete.\n */\nfunction collectContentEncodingEdits(\n  source: string,\n  sourceStart: number,\n  node: CborItem\n): AppSeqEncodingEdit[] | undefined {\n  if (node instanceof CborUint) {\n    const width = node.encodingWidth ?? canonicalEncodingWidth(node.value);\n    const edit = sourceSuffixEdit(source, sourceStart, node, `_${width}`);\n    return edit ? [edit] : [];\n  }\n  if (node instanceof CborNint) {\n    const width = node.encodingWidth ?? canonicalEncodingWidth(node.argument);\n    const edit = sourceSuffixEdit(source, sourceStart, node, `_${width}`);\n    return edit ? [edit] : [];\n  }\n  if (node instanceof CborFloat) {\n    const precision = node.precision ?? autoSelectFloatPrecision(node.value);\n    const suffix =\n      precision === 'half' ? '_1' : precision === 'single' ? '_2' : '_3';\n    const edit = sourceSuffixEdit(source, sourceStart, node, suffix);\n    return edit ? [edit] : [];\n  }\n  if (node instanceof CborByteString) {\n    const width =\n      node.encodingWidth ?? canonicalEncodingWidth(BigInt(node.value.length));\n    const edit = sourceSuffixEdit(source, sourceStart, node, `_${width}`);\n    return edit ? [edit] : [];\n  }\n  if (node instanceof CborTextString) {\n    const width =\n      node.encodingWidth ??\n      canonicalEncodingWidth(BigInt(textEncoder.encode(node.value).length));\n    const edit = sourceSuffixEdit(source, sourceStart, node, `_${width}`);\n    return edit ? [edit] : [];\n  }\n  if (node instanceof CborArray) {\n    const edits: AppSeqEncodingEdit[] = [];\n    if (node.indefiniteLength) return undefined;\n    if (node.start !== undefined) {\n      const tokenizer = new Tokenizer(source, { offset: node.start });\n      const open = tokenizer.consume();\n      const next = tokenizer.peek();\n      const hasIndicator = next.type === 'ENCODING_INDICATOR';\n      const width =\n        node.encodingWidth ?? canonicalEncodingWidth(BigInt(node.items.length));\n      const suffix = `_${width}`;\n      const nextSourceChar = source[open.endOffset] ?? '';\n      const separator =\n        !hasIndicator && /[+\\-.0-9A-Z_a-z]/.test(nextSourceChar) ? ' ' : '';\n      edits.push({\n        start: (hasIndicator ? next.offset : open.endOffset) - sourceStart,\n        end: (hasIndicator ? next.endOffset : open.endOffset) - sourceStart,\n        // An inserted container indicator needs a separator before an\n        // immediately-adjacent item (`[_i24]` lexes as one identifier).\n        always: suffix + separator,\n        never: '',\n      });\n    }\n    for (const item of node.items) {\n      const itemEdits = collectContentEncodingEdits(source, sourceStart, item);\n      if (itemEdits === undefined) return undefined;\n      edits.push(...itemEdits);\n    }\n    return edits;\n  }\n  return undefined;\n}\n\nfunction attachComments(\n  root: CborItem,\n  comments: EdnComment[],\n  source: string\n): void {\n  if (comments.length === 0) return;\n  const nodes = collectNodes(root);\n  const lineAt = buildLineAt(source);\n\n  // Two sorted views over the pre-order node list, so each comment resolves\n  // its neighbours in O(log N) instead of re-filtering and re-sorting the\n  // whole list per comment.  Both sorts are stable, so nodes with equal keys\n  // keep their pre-order (parent before child) relative order.\n  const byStart = [...nodes].sort((a, b) => a.start - b.start || b.end - a.end);\n  const byEnd = [...nodes].sort((a, b) => a.end - b.end || a.start - b.start);\n\n  // The tokenizer appends comments in source order; sort defensively so the\n  // container sweep below stays correct for out-of-order callers.\n  const ordered = [...comments].sort((a, b) => a.start - b.start);\n\n  // Container-sweep state shared across comments (comments are processed in\n  // ascending start order, so pushes and pops are monotone).\n  const enclosing: NodeInfo[] = [];\n  let nextToPush = 0;\n\n  for (const raw of ordered) {\n    const comment: CborComment = { ...raw };\n\n    // prev: node with the largest end <= comment start (ties: largest start).\n    // byEnd is (end asc, start asc), so this is the last index with\n    // end <= raw.start, found by upper-bound binary search.\n    let lo = 0;\n    let hi = byEnd.length;\n    while (lo < hi) {\n      const mid = (lo + hi) >> 1;\n      if (byEnd[mid].end <= raw.start) lo = mid + 1;\n      else hi = mid;\n    }\n    const prev = lo > 0 ? byEnd[lo - 1] : undefined;\n\n    const separatorBeforeComment = prev\n      ? source.slice(prev.end, raw.start)\n      : '';\n    if (\n      prev &&\n      lineAt(prev.end) === raw.line &&\n      !separatorBeforeComment.includes(':')\n    ) {\n      addComment(prev.node, 'trailing', comment);\n      continue;\n    }\n\n    // container: innermost node with start < comment start and comment end\n    // < node end.  Node spans nest properly and a comment never straddles a\n    // node boundary (it is whitespace between tokens), so an interval-stack\n    // sweep over byStart works: push nodes starting before the comment,\n    // pop nodes that ended before it — the stack top is the container.\n    while (\n      nextToPush < byStart.length &&\n      byStart[nextToPush].start < raw.start\n    ) {\n      const n = byStart[nextToPush++];\n      while (\n        enclosing.length > 0 &&\n        enclosing[enclosing.length - 1].end <= n.start\n      )\n        enclosing.pop();\n      enclosing.push(n);\n    }\n    while (\n      enclosing.length > 0 &&\n      enclosing[enclosing.length - 1].end <= raw.start\n    )\n      enclosing.pop();\n    const container =\n      enclosing.length > 0 ? enclosing[enclosing.length - 1] : undefined;\n\n    // next: node with the smallest start >= comment end (ties: largest end).\n    // byStart is (start asc, end desc), so this is the first index with\n    // start >= raw.end, found by lower-bound binary search.\n    lo = 0;\n    hi = byStart.length;\n    while (lo < hi) {\n      const mid = (lo + hi) >> 1;\n      if (byStart[mid].start < raw.end) lo = mid + 1;\n      else hi = mid;\n    }\n    const next = lo < byStart.length ? byStart[lo] : undefined;\n\n    if (!container || (next && next.end <= container.end)) {\n      if (next) {\n        comment.sameLine = lineAt(raw.end) === lineAt(next.start);\n        addComment(next.node, 'leading', comment);\n        continue;\n      }\n    }\n\n    // No enclosing node and no following node: the comment lies entirely\n    // after `root.end` (a comment before `root.start` is always caught by\n    // the `next`-leading branch above, since `root` is itself a collected\n    // node). This happens when this parse is one item of a CDN Sequence\n    // (`allowTrailing: true`) — the tokenizer's one-token lookahead reads\n    // past this item's closing bracket into a comment that actually\n    // belongs to whatever follows. Attaching it here would duplicate the\n    // sequence-level leading-comment assignment `fromCDNSeq` already makes\n    // for the next item, so it is dropped instead of defaulting to `root`.\n    if (!container) continue;\n\n    addComment(container.node, 'dangling', comment);\n  }\n}\n\nfunction collectNodes(root: CborItem): NodeInfo[] {\n  const out: NodeInfo[] = [];\n  const visit = (node: CborItem) => {\n    if (node.start !== undefined && node.end !== undefined)\n      out.push({ node, start: node.start, end: node.end });\n    if (node instanceof CborArray || node instanceof CborEmbeddedCBOR) {\n      for (const item of node.items) visit(item);\n      return;\n    }\n    if (node instanceof CborMap) {\n      for (const [key, value] of node.entries) {\n        visit(key);\n        visit(value);\n      }\n      return;\n    }\n    if (\n      node instanceof CborIndefiniteByteString ||\n      node instanceof CborIndefiniteTextString\n    ) {\n      for (const chunk of node.chunks) visit(chunk);\n      return;\n    }\n    if (node instanceof CborTag) visit(node.content);\n  };\n  visit(root);\n  return out;\n}\n\nfunction addComment(\n  node: CborItem,\n  placement: 'leading' | 'trailing' | 'dangling',\n  comment: CborComment\n): void {\n  node.comments ??= {};\n  node.comments[placement] ??= [];\n  node.comments[placement].push(comment);\n}\n\n/**\n * A comment right after the very last fragment of a `+`/`...` chain ties,\n * in source position, with the enclosing `CborEllipsis`'s own end — there\n * is no closing delimiter after the last fragment (unlike an array's `]` or\n * a map's `}`) to give the chain a later end of its own — so\n * `attachComments`'s prev/next tie-break resolves it in favour of the more\n * specific, innermost node: the comment lands as `trailing` on the last\n * fragment itself, not on the `CborEllipsis`.\n *\n * Move it up onto the `CborEllipsis`'s own `comments.trailing` so the\n * ordinary `entryTrailing`/root-`toCDN()` machinery renders it after\n * whatever separator the parent adds (`,`, `:`, a closing bracket) instead\n * of `CborEllipsis._toCDN()` folding it into the chain's own body — which\n * would place a `#`/`//` line comment *before* that separator, swallowing\n * it into the comment on re-parse (e.g. `[h'aa' + ..., # next\\n 1]` would\n * otherwise render the trailing `,` inside the comment text itself).\n */\nfunction promoteEllipsisTailComments(node: CborItem): void {\n  if (node instanceof CborEllipsis) {\n    if (node.content instanceof CborArray) {\n      const items = node.content.items;\n      for (const item of items) promoteEllipsisTailComments(item);\n      const last = items[items.length - 1];\n      const lastTrailing = last?.comments?.trailing;\n      if (\n        lastTrailing !== undefined &&\n        lastTrailing.length > 0 &&\n        !node.comments?.trailing?.length\n      ) {\n        node.comments ??= {};\n        node.comments.trailing = lastTrailing;\n        last.comments!.trailing = undefined;\n      }\n    }\n    return;\n  }\n  if (node instanceof CborArray || node instanceof CborEmbeddedCBOR) {\n    for (const item of node.items) promoteEllipsisTailComments(item);\n    return;\n  }\n  if (node instanceof CborMap) {\n    for (const [key, value] of node.entries) {\n      promoteEllipsisTailComments(key);\n      promoteEllipsisTailComments(value);\n    }\n    return;\n  }\n  if (\n    node instanceof CborIndefiniteByteString ||\n    node instanceof CborIndefiniteTextString\n  ) {\n    for (const chunk of node.chunks) promoteEllipsisTailComments(chunk);\n    return;\n  }\n  if (node instanceof CborTag) promoteEllipsisTailComments(node.content);\n}\n\nfunction buildLineAt(source: string): (offset: number) => number {\n  const starts = [0];\n  for (let i = 0; i < source.length; i++) {\n    if (source[i] === '\\n') starts.push(i + 1);\n  }\n  return (offset: number): number => {\n    let target = Math.max(0, Math.min(source.length, offset));\n    if (target > 0 && target === source.length) target--;\n    let lo = 0;\n    let hi = starts.length - 1;\n    while (lo <= hi) {\n      const mid = (lo + hi) >> 1;\n      if (starts[mid] <= target) lo = mid + 1;\n      else hi = mid - 1;\n    }\n    return hi + 1;\n  };\n}\n\n// ─── Missing-extension hints ──────────────────────────────────────────────────\n\nconst bundledExtensionHint = (name: string): string =>\n  `import { ${name} } from '@cbortech/cbor' and pass it via the 'extensions' option (extensions: [${name}])`;\nconst externalExtensionHint = (name: string, pkg: string): string =>\n  `install ${pkg}, import { ${name} } from '${pkg}', and pass it via the 'extensions' option (extensions: [${name}])`;\nconst builtinDisabledHint = (name: string): string =>\n  `'${name}' is a default built-in extension that was excluded via the 'builtinExtensions' option; add it back to that array (or omit 'builtinExtensions' to use the default set)`;\n\n/**\n * App-string prefixes handled by known opt-in extensions or by default\n * built-ins that can be excluded via `builtinExtensions`, mapped to guidance\n * on how to (re-)enable them. Used to emit a non-fatal hint when such a\n * prefix is encountered without the corresponding extension registered.\n */\nconst MISSING_EXTENSION_HINTS: ReadonlyMap<string, string> = new Map([\n  ['b32', bundledExtensionHint('b32')],\n  ['h32', bundledExtensionHint('h32')],\n  ['same', bundledExtensionHint('same')],\n  ['hash', externalExtensionHint('hash', '@cbortech/hash-extension')],\n  ['uuid', externalExtensionHint('uuid', '@cbortech/uuid-extension')],\n  ['UUID', externalExtensionHint('uuid', '@cbortech/uuid-extension')],\n  // Only reachable via a non-default `builtinExtensions` override — these\n  // are otherwise always present in the default bundled set.\n  ['dt', builtinDisabledHint('dt')],\n  ['DT', builtinDisabledHint('dt')],\n  ['ip', builtinDisabledHint('ip')],\n  ['IP', builtinDisabledHint('ip')],\n  ['cri', builtinDisabledHint('cri')],\n  ['CRI', builtinDisabledHint('cri')],\n  ['t1', builtinDisabledHint('t1')],\n  ['b1', builtinDisabledHint('b1')],\n  ['ilbs', builtinDisabledHint('ilbs')],\n  ['ilts', builtinDisabledHint('ilts')],\n  ['float', builtinDisabledHint('float')],\n]);\n\n/**\n * One atom of a byte-string `+`/ellipsis chain: either a byte fragment or an\n * ellipsis marker, tagged with whether a genuine `+` from the source\n * precedes it (`real`) as opposed to sitting inside a single `h'xx...yy'`\n * literal's own `...` notation. An ellipsis atom also tracks whether it came\n * from such a literal at all (`fromByteLiteral`), regardless of its own\n * position within it (leading, trailing, or in the middle) — as opposed to a\n * bare standalone `...` token — and, when it did, that literal's own raw\n * source text (`literalSource`, e.g. `h'AB...CD'` verbatim, case/whitespace/\n * comments and all) for `preserveByteString` to round-trip. See\n * `CDNParser._consumeByteEllipsisChain`.\n */\ntype ByteEllipsisAtom =\n  | {\n      bytes: Uint8Array;\n      source?: string;\n      commentSyntax?: ByteCommentSyntax;\n      real: boolean;\n      /**\n       * Source span this atom occupies — its own literal token's span for a\n       * direct `+`-joined fragment, or the enclosing `h'xx...yy'` token's\n       * whole span for an internal segment split out of it (see\n       * `_elidedHexAtoms`: no comment can ever sit between two of that\n       * token's own internal segments, so sharing the outer span is safe and\n       * still lets an *outer* boundary comment resolve correctly against the\n       * group as a whole). Lets `_buildFromByteAtoms` stamp `start`/`end` on\n       * the `CborByteString`/`CborEllipsis` nodes it builds, so the generic\n       * `attachComments` pass (and `CborByteString._toCDN`'s /\n       * `CborEllipsis._renderPreservedBytesElision`'s own dangling-comment\n       * lookups) can place a comment between two `+`-joined parts instead of\n       * dropping it.\n       */\n      start?: number;\n      end?: number;\n    }\n  | {\n      ellipsis: true;\n      real: boolean;\n      fromByteLiteral: boolean;\n      literalSource?: string;\n      /** See the byte-atom variant's `start`/`end` doc above. */\n      start?: number;\n      end?: number;\n    };\n\n// ─── Parser ───────────────────────────────────────────────────────────────────\n\nclass CDNParser {\n  /** Lookup from app-prefix → extension (user extensions override built-ins). */\n  private readonly extByPrefix: Map<string, CborExtension>;\n  /** Lookup from tag number → extension. */\n  private readonly extByTag: Map<bigint, CborExtension>;\n\n  private readonly unresolvedExtension: 'cpa999' | 'error';\n\n  /** Warnings accumulated during the current parseValue() call. */\n  private _pendingWarnings: ParseWarning[] = [];\n\n  /** Prefixes for which a missing-extension hint has already been emitted. */\n  private readonly _hintedPrefixes = new Set<string>();\n\n  constructor(\n    private readonly t: Tokenizer,\n    private readonly _options: FromCDNOptions\n  ) {\n    this.extByPrefix = new Map();\n    this.extByTag = new Map();\n    this.unresolvedExtension = _options.unresolvedExtension ?? 'cpa999';\n    const builtins = resolveBuiltinExtensions(_options.builtinExtensions);\n    for (const ext of [...builtins, ...(_options.extensions ?? [])]) {\n      for (const prefix of ext.appStringPrefixes ?? [])\n        this.extByPrefix.set(prefix, ext);\n      for (const tag of ext.tagNumbers ?? []) this.extByTag.set(tag, ext);\n    }\n    this.t.onEscapeWarning = (msg, offset, line, col, endOffset) => {\n      const w: ParseWarning = {\n        message: msg,\n        offset,\n        line,\n        column: col,\n        endOffset,\n      };\n      this._pendingWarnings.push(w);\n      if (this._options.onWarning) this._options.onWarning(w);\n      else if (!this._options.silent)\n        console.warn(\n          `CDN strict violation at line ${line}, column ${col}: ${msg}`\n        );\n      if (this._options.strict !== false)\n        throw new CdnSyntaxError(msg, { offset, line, column: col, endOffset });\n    };\n  }\n\n  parse(): CborItem {\n    const value = this.parseValue();\n    if (this._options.allowTrailing) return value;\n    const next = this.t.peek();\n    if (next.type !== 'EOF') {\n      this._warnOrFail(\n        `unexpected token after value: ${JSON.stringify(next.value)}`,\n        next\n      );\n      // Reached only in non-strict mode (_warnOrFail throws in strict mode).\n      // Drain the pending warning into the returned value's AST node so it\n      // is visible to callers that inspect node.warnings directly.\n      if (this._pendingWarnings.length > 0) {\n        value.warnings ??= [];\n        value.warnings.push(...this._pendingWarnings);\n        this._pendingWarnings = [];\n      }\n      // Scan the rest of the input so that hard lexer errors in the trailing\n      // content (e.g. unterminated strings) still throw regardless of the\n      // strict setting.\n      while (this.t.peek().type !== 'EOF') this.t.consume();\n    }\n    return value;\n  }\n\n  parseValue(): CborItem {\n    const start = this.t.peek().offset;\n    const node = this._parseValueNode();\n    if (this.t.peek().type === 'UNDERSCORE') {\n      const tok = this.t.consume();\n      this._warnOrFail(\n        'bare _ is not a valid encoding indicator; use _0, _1, _2, _3, or _i',\n        tok\n      );\n    }\n    if (this._pendingWarnings.length > 0) {\n      node.warnings ??= [];\n      for (const w of this._pendingWarnings) node.warnings.push(w);\n      this._pendingWarnings = [];\n    }\n    node.start = start;\n    node.end = this.t.lastEndOffset;\n    return node;\n  }\n\n  private _parseValueNode(): CborItem {\n    const tok = this.t.peek();\n    switch (tok.type) {\n      case 'INTEGER':\n        return this.parseIntegerOrTag();\n      case 'FLOAT':\n        return this.parseFloat();\n      case 'TSTR':\n      case 'RAWSTRING':\n        return this.parseString();\n      case 'BYTES_HEX':\n      case 'SQSTR':\n      case 'BYTES_B64': {\n        this.t.consume();\n        return this._parseBytesConcat(\n          this._decodeBytesToken(tok),\n          tok.type,\n          tok.raw,\n          tok.offset,\n          tok.endOffset\n        );\n      }\n      case 'EMPTY_INDEF_BYTES':\n        this.t.consume();\n        return new CborIndefiniteByteString([]);\n      case 'EMPTY_INDEF_TEXT':\n        this.t.consume();\n        return new CborIndefiniteTextString([]);\n      case 'TRUE':\n        this.t.consume();\n        return new CborSimple(21);\n      case 'FALSE':\n        this.t.consume();\n        return new CborSimple(20);\n      case 'NULL':\n        this.t.consume();\n        return new CborSimple(22);\n      case 'UNDEFINED':\n        this.t.consume();\n        return new CborSimple(23);\n      case 'SIMPLE':\n        return this.parseSimple();\n      case 'LBRACKET':\n        return this.parseArray();\n      case 'LBRACE':\n        return this.parseMap();\n      case 'LPAREN':\n        return this.parseIndefGroup();\n      case 'LT_LT':\n        return this.parseEmbeddedCBOR();\n      case 'APP_STRING': {\n        this.t.consume();\n        // Consume optional encoding indicator (e.g. float'fe00'_2).\n        let appStrEw: EncodingWidth | undefined;\n        let appStrEiRaw = '';\n        if (this.t.peek().type === 'ENCODING_INDICATOR') {\n          const eiTok = this.t.consume();\n          appStrEw = this._resolveEncodingWidth(eiTok.value, eiTok);\n          appStrEiRaw = eiTok.raw;\n        }\n        const ext = this.extByPrefix.get(tok.appPrefix!);\n        if (!ext?.parseAppString) {\n          if (!ext) this._hintMissingExtension(tok.appPrefix!, tok);\n          if (this.unresolvedExtension === 'cpa999')\n            return new CborUnresolvedAppExt(tok.appPrefix!, [\n              new CborTextString(tok.value),\n            ]);\n          this._fail(\n            `unknown app-string extension: ${JSON.stringify(tok.appPrefix)}`,\n            tok\n          );\n        }\n        {\n          const warnsBefore = this._pendingWarnings.length;\n          try {\n            const result = ext.parseAppString(\n              tok.appPrefix!,\n              tok.value,\n              this._extOnError(tok),\n              appStrEw !== undefined ? { encodingWidth: appStrEw } : undefined\n            );\n            // Generic EI post-processing: apply encoding indicator when the\n            // extension didn't handle it itself (e.g. dt'...'_2).\n            if (appStrEw !== undefined)\n              this._applyEiToResult(result, appStrEw, tok);\n            if (ext.preserveAppSeqSource === 'optional') {\n              // Same rationale as the APP_SEQUENCE case below: tack the\n              // source onto the same result node so preserveAppSequence can\n              // round-trip prefix`...` (and non-canonical prefix'...')\n              // spellings without changing the node's class/identity.\n              result.appSeqSource = tok.raw + appStrEiRaw;\n              return result;\n            }\n            // Propagate ednSource so preserveByteString / appStrings round-trips correctly.\n            // instanceof narrows the type; getPrototypeOf excludes subclasses like CborIpExt.\n            if (\n              result instanceof CborByteString &&\n              Object.getPrototypeOf(result) === CborByteString.prototype &&\n              result.ednSource === undefined\n            )\n              return new CborByteString(result.value, {\n                ednEncoding: result.ednEncoding,\n                encodingWidth: result.encodingWidth,\n                ednSource: tok.raw + appStrEiRaw,\n                // A prefix name alone can't say which comment syntax (if\n                // any) this content actually uses: a user extension may be\n                // registered under the same prefix as a built-in (`ext`\n                // here is whichever one actually resolved — see the\n                // registration order in the constructor). Only strip\n                // comments from preserveByteString's spelling when `ext` is\n                // provably the specific built-in b32/h32 object.\n                ednCommentSyntax:\n                  ext === b32 || ext === h32 ? 'full' : undefined,\n              });\n            if (result instanceof CborFloat && result.ednSource === undefined)\n              result.ednSource = tok.raw + appStrEiRaw;\n            return result;\n          } catch (e) {\n            if (this._options.strict !== false) throw e;\n            if (this._pendingWarnings.length === warnsBefore)\n              this._warn(e instanceof Error ? e.message : String(e), tok);\n            return new CborUnresolvedAppExt(tok.appPrefix!, [\n              new CborTextString(tok.value),\n            ]);\n          }\n        }\n      }\n      case 'APP_SEQUENCE': {\n        const commentStartIndex = this.t.comments.length;\n        this.t.consume();\n        const items: CborItem[] = [];\n        while (this.t.peek().type !== 'GT_GT') {\n          if (this.t.peek().type === 'EOF')\n            this._fail(`unterminated ${tok.appPrefix!}<<...>>`, tok);\n          if (items.length > 0) {\n            if (this.t.peek().type === 'COMMA') {\n              this.t.consume();\n              if (this.t.peek().type === 'GT_GT') break; // trailing comma\n            } else if (this.t.peek().offset === this.t.lastEndOffset) {\n              this._warnOrFail(\n                '<<...>> items must be separated by \",\" or whitespace',\n                this.t.peek()\n              );\n            }\n          }\n          items.push(this.parseValue());\n        }\n        this.expect('GT_GT');\n        let seqEw: EncodingWidth | undefined;\n        let seqEiTok: Token | undefined;\n        if (this.t.peek().type === 'ENCODING_INDICATOR') {\n          seqEiTok = this.t.consume();\n          seqEw = this._resolveEncodingWidth(seqEiTok.value, seqEiTok);\n        }\n        const seqExt = this.extByPrefix.get(tok.appPrefix!);\n        if (!seqExt) {\n          this._hintMissingExtension(tok.appPrefix!, tok);\n          if (this.unresolvedExtension === 'cpa999')\n            return new CborUnresolvedAppExt(tok.appPrefix!, items);\n          this._fail(\n            `unknown app-string extension: ${JSON.stringify(tok.appPrefix)}`,\n            tok\n          );\n        }\n        if (!seqExt.parseAppSequence)\n          this._fail(\n            `app-string extension ${JSON.stringify(tok.appPrefix)} does not support <<...>> form`,\n            tok\n          );\n        {\n          const warnsBefore = this._pendingWarnings.length;\n          try {\n            const result = seqExt.parseAppSequence(\n              tok.appPrefix!,\n              items,\n              this._extOnError(tok)\n            );\n            if (seqEw !== undefined)\n              this._applyEiToResult(result, seqEw, seqEiTok ?? tok);\n            const rawSource = this.t.source.slice(\n              tok.offset,\n              this.t.lastEndOffset\n            );\n            if (seqExt.preserveAppSeqSource === 'optional') {\n              // Tack the source onto the same result node (preserving its\n              // class/identity) rather than wrapping it; the node's own\n              // _toCDN() decides whether to use it (see preserveAppSequence).\n              result.appSeqSource = rawSource;\n              result.appSeqComments = relativeComments(\n                this.t.comments,\n                commentStartIndex,\n                tok.offset,\n                this.t.lastEndOffset\n              );\n              // Exact split point for adjustAppSeqIndicator to strip the\n              // sole inner item's own indicator by position rather than by\n              // pattern-matching text near '>>' (which whitespace, a\n              // trailing comma, or a comment between the item and '>>'\n              // would defeat).\n              if (items.length === 1) {\n                if (items[0].end !== undefined)\n                  result.appSeqInnerEnd = items[0].end - tok.offset;\n                result.appSeqSourceFeatures = appSeqSourceFeatures(items[0]);\n              }\n            } else if (result instanceof CborFloat) {\n              if (result.ednSource === undefined) result.ednSource = rawSource;\n            } else if (seqExt.preserveAppSeqSource) {\n              return new CborAppSeqResult(result, rawSource);\n            }\n            return result;\n          } catch (e) {\n            if (this._options.strict !== false) throw e;\n            if (this._pendingWarnings.length === warnsBefore)\n              this._warn(e instanceof Error ? e.message : String(e), tok);\n            return new CborUnresolvedAppExt(tok.appPrefix!, items);\n          }\n        }\n      }\n      case 'ELLIPSIS': {\n        this.t.consume();\n        if (this.t.peek().type !== 'PLUS') return new CborEllipsis();\n        const items: CborItem[] = [new CborEllipsis()];\n        while (this.t.peek().type === 'PLUS') {\n          this.t.consume();\n          items.push(this.parseValue());\n        }\n        // Every item here came from an explicit `+` (this generic chain has\n        // no notion of an elided-hex literal's internal `...`), so every\n        // boundary is real.\n        return new CborEllipsis(\n          items,\n          items.map(() => true)\n        );\n      }\n      case 'BYTES_HEX_ELIDED': {\n        this.t.consume();\n        return this._parseHexElidedConcat(tok);\n      }\n      default:\n        this._fail(`unexpected token: ${JSON.stringify(tok.value)}`, tok);\n    }\n  }\n\n  private parseIntegerOrTag(): CborItem {\n    const commentStartIndex = this.t.comments.length;\n    const tok = this.t.consume(); // INTEGER\n    const { numStr, rawSuffix } = parseIntegerRaw(tok.value);\n    let tagIndicatorStart =\n      rawSuffix !== undefined ? tok.endOffset - 2 : tok.endOffset;\n    let tagIndicatorEnd = tok.endOffset;\n    // Hex/octal/binary literals return before the suffix check in the tokenizer,\n    // so their encoding indicator arrives as a separate ENCODING_INDICATOR token.\n    let encodingWidth =\n      rawSuffix !== undefined\n        ? this._resolveEncodingWidth(rawSuffix, tok)\n        : this.consumeEncodingIndicator(undefined, (eiTok) => {\n            tagIndicatorStart = eiTok.offset;\n            tagIndicatorEnd = eiTok.endOffset;\n          });\n    const n = parseBigInt(numStr);\n    // tok.raw keeps a leading '+' that tok.value drops (e.g. \"+42\" → value\n    // \"42\", raw \"+42\"); mirror the same suffix stripping applied to numStr\n    // so the preserved spelling matches what the user actually wrote.\n    const ednSource = rawSuffix !== undefined ? tok.raw.slice(0, -2) : tok.raw;\n\n    // Out-of-range integers become bignum tags per RFC 8949 §3.4.3.\n    // Tag numbers must fit in uint64, so a value > UINT64_MAX before '(' is an error.\n    if (n > 0xffff_ffff_ffff_ffffn) {\n      if (this.t.peek().type === 'LPAREN')\n        this._fail('tag number exceeds maximum uint64', tok);\n      return new CborBigUint(n);\n    }\n    if (n < -(0xffff_ffff_ffff_ffffn + 1n)) {\n      return new CborBigNint(n);\n    }\n\n    // Validate that the value fits in the requested encoding width.\n    // For nint, the CBOR argument is abs(n)−1 (e.g. -1 → 0, -24 → 23).\n    if (encodingWidth !== undefined) {\n      const storedValue = n >= 0n ? n : -(n + 1n);\n      encodingWidth = this._validateEncodingFit(\n        storedValue,\n        encodingWidth,\n        tok\n      );\n    }\n\n    const intNode =\n      n >= 0n\n        ? new CborUint(n, { encodingWidth, ednSource })\n        : new CborNint(n, { encodingWidth, ednSource });\n\n    // integer followed by '(' → tagged data item\n    if (this.t.peek().type === 'LPAREN') {\n      if (!(intNode instanceof CborUint))\n        this._fail('tag number must be non-negative', tok);\n      this.t.consume(); // (\n      // Rescue setup warnings before content's parseValue() drains them into the content node.\n      const setupWarnings = this._pendingWarnings.splice(0);\n      const content = this.parseValue();\n      this.expect('RPAREN');\n      const tagNum = intNode.value;\n      const ext = this.extByTag.get(tagNum);\n      if (ext?.parseTag) {\n        const result = ext.parseTag(tagNum, content);\n        if (result !== undefined) {\n          if (result instanceof CborTag) {\n            if (\n              encodingWidth !== undefined &&\n              result.encodingWidth === undefined\n            )\n              result.encodingWidth = encodingWidth;\n            if (result.ednSource === undefined) result.ednSource = ednSource;\n            if (\n              ext.preserveAppSeqSource === 'optional' &&\n              result.appSeqSource === undefined\n            ) {\n              // Raw tag notation (e.g. 1(1749772800)) is itself a spelling\n              // that preserveAppSequence should be able to keep instead of\n              // upgrading it to regenerated DT'...' notation.\n              result.appSeqSource = this.t.source.slice(\n                tok.offset,\n                this.t.lastEndOffset\n              );\n              result.appSeqComments = relativeComments(\n                this.t.comments,\n                commentStartIndex,\n                tok.offset,\n                this.t.lastEndOffset\n              );\n              const tagWidth =\n                result.encodingWidth ?? canonicalEncodingWidth(result.tag);\n              const contentEdits = collectContentEncodingEdits(\n                this.t.source,\n                tok.offset,\n                result.content\n              );\n              result.appSeqEncodingEdits = [\n                {\n                  start: tagIndicatorStart - tok.offset,\n                  end: tagIndicatorEnd - tok.offset,\n                  always: `_${tagWidth}`,\n                  never: '',\n                },\n                ...(contentEdits ?? []),\n              ];\n              if (contentEdits === undefined)\n                result.appSeqEncodingEditsComplete = false;\n              result.appSeqSourceFeatures = appSeqSourceFeatures(content);\n            }\n          }\n          if (setupWarnings.length > 0) {\n            result.warnings ??= [];\n            result.warnings.push(...setupWarnings);\n          }\n          return result;\n        }\n      }\n      const tagResult = new CborTag(tagNum, content, {\n        encodingWidth,\n        ednSource,\n      });\n      if (setupWarnings.length > 0) {\n        tagResult.warnings ??= [];\n        tagResult.warnings.push(...setupWarnings);\n      }\n      return tagResult;\n    }\n    return intNode;\n  }\n\n  private parseFloat(): CborItem {\n    const tok = this.t.consume(); // FLOAT\n    const onRecoverableError = (msg: string) => this._warnOrFail(msg, tok);\n    const { value, precision } = parseFloatToken(tok.value, onRecoverableError);\n    if (precision === 'half' || precision === 'single') {\n      const roundTripped =\n        precision === 'half'\n          ? float16BitsToFloat64(float64ToFloat16Bits(value))\n          : Math.fround(value);\n      const lossless =\n        Object.is(value, roundTripped) || (isNaN(value) && isNaN(roundTripped));\n      if (!lossless)\n        onRecoverableError(\n          `${value} cannot be exactly represented as ${precision === 'half' ? 'f16 (_1)' : 'f32 (_2)'}; use _3 or remove the indicator`\n        );\n    }\n    // tok.raw keeps a leading '+' that tok.value drops (e.g. \"+1.5\" → value\n    // \"1.5\", raw \"+1.5\"; likewise \"+Infinity\" → value \"Infinity\").\n    return new CborFloat(value, { precision, literalSource: tok.raw });\n  }\n\n  private parseString(): CborItem {\n    const tok = this.t.consume(); // STRING\n\n    // Fast path: no concatenation\n    if (this.t.peek().type !== 'PLUS') {\n      const ew = this.consumeEncodingIndicator(() =>\n        BigInt(textEncoder.encode(tok.value).length)\n      );\n      if (tok.type === 'RAWSTRING')\n        return new CborTextString(tok.value, {\n          ednSource: tok.raw,\n          ...(ew !== undefined ? { encodingWidth: ew } : {}),\n        });\n      return new CborTextString(tok.value, {\n        quotedEdnSource: tok.raw,\n        ...(ew !== undefined ? { encodingWidth: ew } : {}),\n      });\n    }\n\n    // Concatenation chain — may include ellipsis, producing CborEllipsis\n    let hasEllipsis = false;\n    const parts: Array<\n      | {\n          text: string;\n          source?: string;\n          isByteString?: boolean;\n          start: number;\n          end: number;\n        }\n      | { ellipsis: true; start: number; end: number }\n    > = [\n      tok.type === 'RAWSTRING'\n        ? {\n            text: tok.value,\n            source: tok.raw,\n            start: tok.offset,\n            end: tok.endOffset,\n          }\n        : { text: tok.value, start: tok.offset, end: tok.endOffset },\n    ];\n\n    while (this.t.peek().type === 'PLUS') {\n      this.t.consume(); // +\n      const next = this.t.peek();\n      if (next.type === 'ELLIPSIS') {\n        this.t.consume();\n        parts.push({ ellipsis: true, start: next.offset, end: next.endOffset });\n        hasEllipsis = true;\n      } else if (next.type === 'TSTR' || next.type === 'RAWSTRING') {\n        this.t.consume();\n        parts.push(\n          next.type === 'RAWSTRING'\n            ? {\n                text: next.value,\n                source: next.raw,\n                start: next.offset,\n                end: next.endOffset,\n              }\n            : { text: next.value, start: next.offset, end: next.endOffset }\n        );\n      } else if (this._isBytesToken(next.type)) {\n        this.t.consume();\n        parts.push({\n          text: this._decodeUtf8(this._decodeBytesToken(next), next),\n          // §5.1: this part is a byte-string literal decoded to text, not a\n          // double-quoted literal — appSeqSourceFeatures must attribute it\n          // to `byteString`, not the unpreservable `textString`, since both\n          // leave `source` undefined here.\n          isByteString: true,\n          start: next.offset,\n          end: next.endOffset,\n        });\n      } else {\n        this._fail(\n          `expected string or byte string after +, got ${JSON.stringify(next.value)}`,\n          next\n        );\n      }\n    }\n\n    if (!hasEllipsis) {\n      // No ellipsis — join all text fragments into a single CborTextString,\n      // keeping the part boundaries for `preserveConcatenation`.\n      const texts = parts.map((p) => ('text' in p ? p.text : ''));\n      const sources = parts.map((p) => ('text' in p ? p.source : undefined));\n      const isByteStringFlags = parts.map((p) =>\n        'text' in p ? (p.isByteString ?? false) : false\n      );\n      const spans = parts.map((p) => ({ start: p.start, end: p.end }));\n      const joined = texts.join('');\n      const ew = this.consumeEncodingIndicator(() =>\n        BigInt(textEncoder.encode(joined).length)\n      );\n      return new CborTextString(joined, {\n        ednParts: texts,\n        ednPartSpans: spans,\n        ...(sources.some((s) => s !== undefined)\n          ? { ednPartSources: sources }\n          : {}),\n        ...(isByteStringFlags.some((b) => b)\n          ? { ednPartIsByteString: isByteStringFlags }\n          : {}),\n        ...(ew !== undefined ? { encodingWidth: ew } : {}),\n      });\n    }\n\n    // Build 888([...]) with consolidated adjacent text fragments, retaining\n    // the original boundaries and raw source spellings within each fragment.\n    const items: CborItem[] = [];\n    const currentParts: Array<{\n      text: string;\n      source?: string;\n      isByteString?: boolean;\n      start: number;\n      end: number;\n    }> = [];\n    const flushCurrentParts = () => {\n      const texts = currentParts.map((part) => part.text);\n      const currentText = texts.join('');\n      if (currentText !== '') {\n        const sources = currentParts.map((part) => part.source);\n        const isByteStringFlags = currentParts.map(\n          (part) => part.isByteString ?? false\n        );\n        const spans = currentParts.map((part) => ({\n          start: part.start,\n          end: part.end,\n        }));\n        const node = new CborTextString(currentText, {\n          ednParts: texts,\n          ednPartSpans: spans,\n          ...(sources.some((source) => source !== undefined)\n            ? { ednPartSources: sources }\n            : {}),\n          ...(isByteStringFlags.some((b) => b)\n            ? { ednPartIsByteString: isByteStringFlags }\n            : {}),\n        });\n        // Stamp the generic start/end span so `attachComments` (run once,\n        // after the whole tree is built) can attach a comment between this\n        // item and its neighbour in `items` as `leading`/`trailing`, exactly\n        // like any other array entry — see\n        // `CborEllipsis._toCDN`'s text-elision rendering.\n        node.start = currentParts[0]!.start;\n        node.end = currentParts[currentParts.length - 1]!.end;\n        items.push(node);\n      }\n      currentParts.length = 0;\n    };\n    for (const part of parts) {\n      if ('ellipsis' in part) {\n        flushCurrentParts();\n        const ellipsisNode = new CborEllipsis();\n        ellipsisNode.start = part.start;\n        ellipsisNode.end = part.end;\n        items.push(ellipsisNode);\n      } else {\n        currentParts.push(part);\n      }\n    }\n    flushCurrentParts();\n\n    return new CborEllipsis(items);\n  }\n\n  private _isBytesToken(type: string): boolean {\n    return type === 'BYTES_HEX' || type === 'SQSTR' || type === 'BYTES_B64';\n  }\n\n  /**\n   * Decode a hex payload, converting the codec's plain SyntaxError (e.g. odd\n   * length) into a CdnSyntaxError carrying the token's position.\n   */\n  private _hexToBytes(hex: string, tok: Token): Uint8Array {\n    try {\n      return hexToBytes(hex);\n    } catch (e) {\n      if (e instanceof CdnSyntaxError || !(e instanceof SyntaxError)) throw e;\n      this._fail(e.message, tok);\n    }\n  }\n\n  private _decodeBytesToken(tok: Token): Uint8Array {\n    const onRecoverableError = (msg: string) => this._warnOrFail(msg, tok);\n    switch (tok.type) {\n      case 'SQSTR': {\n        // The tokenizer attaches the UTF-8 payload it already encoded;\n        // decoding the hex `value` again would just rebuild the same bytes.\n        const bytes = (tok as SqstrToken)._sqstrBytes;\n        if (bytes !== undefined) return bytes;\n        return this._hexToBytes(tok.value, tok);\n      }\n      case 'BYTES_HEX':\n        return this._hexToBytes(tok.value, tok);\n      case 'BYTES_B64':\n        try {\n          return base64ToBytes(tok.value, onRecoverableError);\n        } catch (e) {\n          if (e instanceof CdnSyntaxError || !(e instanceof SyntaxError))\n            throw e;\n          this._fail(e.message, tok);\n        }\n      default:\n        this._fail(`expected byte string token`, tok);\n    }\n  }\n\n  private _decodeUtf8(bytes: Uint8Array, tok: Token): string {\n    if (this._options.allowInvalidUtf8) return utf8Lenient.decode(bytes);\n    try {\n      return utf8Strict.decode(bytes);\n    } catch {\n      const msg = 'byte string in text concatenation is not valid UTF-8';\n      this._warnOrFail(msg, tok);\n      return utf8Lenient.decode(bytes);\n    }\n  }\n\n  private _tokenTypeToCdnEncoding(type: string): 'hex' | 'base64' {\n    return type === 'BYTES_B64' ? 'base64' : 'hex';\n  }\n\n  /**\n   * Comment syntax (if any) for a *core* byte-string token type (never an\n   * app-string extension's — those are resolved by extension identity, not\n   * token type, since `_isBytesToken` excludes `APP_STRING` and extension\n   * prefixes can never take part in `+`/ellipsis concatenation). `BYTES_HEX`\n   * (and its elided form) uses the full syntax; `BYTES_B64` only `#`; `SQSTR`\n   * none at all.\n   */\n  private _tokenTypeToCommentSyntax(\n    type: string\n  ): ByteCommentSyntax | undefined {\n    if (type === 'BYTES_HEX') return 'full';\n    if (type === 'BYTES_B64') return 'hash-only';\n    return undefined;\n  }\n\n  private _parseBytesConcat(\n    first: Uint8Array,\n    firstType: string,\n    firstSource: string,\n    firstStart: number,\n    firstEnd: number\n  ): CborByteString | CborEllipsis {\n    if (this.t.peek().type !== 'PLUS') {\n      const ew = this.consumeEncodingIndicator(() => BigInt(first.length));\n      const ednEncoding = this._tokenTypeToCdnEncoding(firstType);\n      return new CborByteString(first, {\n        ednEncoding,\n        ednSource: firstSource,\n        ednCommentSyntax: this._tokenTypeToCommentSyntax(firstType),\n        ...(ew !== undefined ? { encodingWidth: ew } : {}),\n      });\n    }\n    const initial: ByteEllipsisAtom[] = [\n      {\n        bytes: first,\n        source: firstSource,\n        commentSyntax: this._tokenTypeToCommentSyntax(firstType),\n        real: false,\n        start: firstStart,\n        end: firstEnd,\n      },\n    ];\n    const atoms = this._consumeByteEllipsisChain(initial);\n    return this._buildFromByteAtoms(\n      atoms,\n      this._tokenTypeToCdnEncoding(firstType)\n    );\n  }\n\n  /**\n   * Parse a BYTES_HEX_ELIDED token (h'xx...yy') and any trailing + concatenation\n   * into a CborEllipsis([h'xx', 888(null), h'yy', ...]).\n   */\n  private _parseHexElidedConcat(firstTok: Token): CborEllipsis {\n    const atoms = this._consumeByteEllipsisChain(\n      this._elidedHexAtoms(firstTok.value, firstTok)\n    );\n    // Always has at least one ellipsis atom — it came from an elided token.\n    return this._buildFromByteAtoms(atoms, 'hex') as CborEllipsis;\n  }\n\n  /**\n   * Consume a `+`-chain of byte-string / `...` / `h'xx...yy'` tokens\n   * following an already-parsed first fragment, returning the flattened,\n   * source-ordered atom list (`initial` plus everything the chain adds).\n   *\n   * Each atom carries `real`: whether a genuine `+` from the source\n   * precedes it — as opposed to an ellipsis or byte segment that sits\n   * *inside* a single `h'xx...yy'` literal's own notation. Two literal\n   * tokens can only end up adjacent with no ellipsis between them by\n   * sitting across a `+` (a single elided-hex token's internal segments are\n   * always ellipsis-separated from each other), so every atom appended here\n   * — the first one from each new token, and every atom of a plain\n   * (non-elided) byte token — is real; only an elided token's *internal*\n   * segments (beyond its first) are not.\n   */\n  private _consumeByteEllipsisChain(\n    initial: ByteEllipsisAtom[]\n  ): ByteEllipsisAtom[] {\n    const atoms = initial;\n    while (this.t.peek().type === 'PLUS') {\n      this.t.consume(); // +\n      const next = this.t.peek();\n      if (next.type === 'ELLIPSIS') {\n        this.t.consume();\n        atoms.push({\n          ellipsis: true,\n          real: true,\n          fromByteLiteral: false,\n          start: next.offset,\n          end: next.endOffset,\n        });\n      } else if (next.type === 'BYTES_HEX_ELIDED') {\n        this.t.consume();\n        const sub = this._elidedHexAtoms(next.value, next);\n        if (sub.length > 0) sub[0]!.real = true;\n        atoms.push(...sub);\n      } else if (this._isBytesToken(next.type)) {\n        this.t.consume();\n        atoms.push({\n          bytes: this._decodeBytesToken(next),\n          source: next.raw,\n          commentSyntax: this._tokenTypeToCommentSyntax(next.type),\n          real: true,\n          start: next.offset,\n          end: next.endOffset,\n        });\n      } else if (next.type === 'TSTR' || next.type === 'RAWSTRING') {\n        // §5.1: when a byte string leads, the right-hand side must also be a\n        // byte string.  Text strings are only allowed on the right of a\n        // text-leading concatenation.  In non-strict mode we UTF-8 encode\n        // the text and continue; in strict mode this is a hard error.\n        this.t.consume();\n        const mixMsg =\n          'text string in a byte-string concatenation is not allowed; ' +\n          \"use a byte string literal (h'...', b64'...', or '...') instead\";\n        this._warnOrFail(mixMsg, next);\n        atoms.push({\n          bytes: textEncoder.encode(next.value),\n          real: true,\n          start: next.offset,\n          end: next.endOffset,\n        });\n      } else {\n        this._fail(\n          `expected byte string after +, got ${JSON.stringify(next.value)}`,\n          next\n        );\n      }\n    }\n    return atoms;\n  }\n\n  /** Flatten a single BYTES_HEX_ELIDED token's own `h'xx...yy...zz'` content\n   *  into atoms, all marked non-`real`: none of its internal segments sit\n   *  across an actual `+`. Every ellipsis atom is `fromByteLiteral: true` —\n   *  it came from this literal's own notation, regardless of where within\n   *  it (leading, trailing, or in the middle). The caller fixes up the very\n   *  first atom's `real` flag if this token itself followed a `+`. */\n  private _elidedHexAtoms(\n    hexWithEllipsis: string,\n    tok: Token\n  ): ByteEllipsisAtom[] {\n    const segments = hexWithEllipsis.split('...');\n    const atoms: ByteEllipsisAtom[] = [];\n    for (let i = 0; i < segments.length; i++) {\n      if (i > 0)\n        atoms.push({\n          ellipsis: true,\n          real: false,\n          fromByteLiteral: true,\n          literalSource: tok.raw,\n          start: tok.offset,\n          end: tok.endOffset,\n        });\n      if (segments[i].length > 0) {\n        atoms.push({\n          bytes: this._hexToBytes(segments[i], tok),\n          commentSyntax: 'full',\n          real: false,\n          start: tok.offset,\n          end: tok.endOffset,\n        });\n      }\n    }\n    return atoms;\n  }\n\n  /**\n   * Build the final `CborByteString` (no ellipsis anywhere) or `CborEllipsis`\n   * from a flattened atom list, consolidating adjacent byte atoms with no\n   * ellipsis between them into one `CborByteString` — retaining `ednParts`\n   * for a fragment that merged multiple `real` (`+`-joined) atoms — and\n   * building a `realBoundary` array parallel to the resulting `CborEllipsis`\n   * items, so `preserveConcatenation` can tell real `+` boundaries apart\n   * from a `h'xx...yy'` literal's own internal notation regardless of where\n   * the `...` falls within it.\n   */\n  private _buildFromByteAtoms(\n    atoms: ByteEllipsisAtom[],\n    ednEncoding: 'hex' | 'base64'\n  ): CborByteString | CborEllipsis {\n    const hasEllipsis = atoms.some((a) => 'ellipsis' in a);\n    if (!hasEllipsis) {\n      const byteParts = atoms as Array<{\n        bytes: Uint8Array;\n        source?: string;\n        commentSyntax?: ByteCommentSyntax;\n        start?: number;\n        end?: number;\n      }>;\n      const concat = this._concatBytes(byteParts.map((p) => p.bytes));\n      const ew = this.consumeEncodingIndicator(() => BigInt(concat.length));\n      return new CborByteString(concat, {\n        ednEncoding,\n        ednParts: byteParts,\n        ...(ew !== undefined ? { encodingWidth: ew } : {}),\n      });\n    }\n\n    const items: CborItem[] = [];\n    const realBoundary: boolean[] = [];\n    const pending: Array<{\n      bytes: Uint8Array;\n      source?: string;\n      commentSyntax?: ByteCommentSyntax;\n      real: boolean;\n      start?: number;\n      end?: number;\n    }> = [];\n    const flushPending = () => {\n      if (pending.length > 0) {\n        const node = new CborByteString(\n          this._concatBytes(pending.map((p) => p.bytes)),\n          {\n            // A single fragment (no merge across a real `+`) still needs its\n            // own source spelling preserved — e.g. the sole byte atom\n            // adjacent to an ellipsis in `h'41' + ...` — so\n            // `preserveByteString` has something to round-trip.\n            ...(pending.length > 1\n              ? {\n                  ednParts: pending.map(\n                    ({ bytes, source, commentSyntax, start, end }) => ({\n                      bytes,\n                      source,\n                      commentSyntax,\n                      start,\n                      end,\n                    })\n                  ),\n                }\n              : {\n                  ednSource: pending[0]!.source,\n                  ednCommentSyntax: pending[0]!.commentSyntax,\n                }),\n          }\n        );\n        // Stamp the generic start/end span so `attachComments` (run once,\n        // after the whole tree is built) can attach a comment between this\n        // item and its neighbour in `items` as `leading`/`trailing`, exactly\n        // like any other array entry — see `CborEllipsis._renderPreservedBytesElision`.\n        node.start = pending[0]!.start;\n        node.end = pending[pending.length - 1]!.end;\n        items.push(node);\n        realBoundary.push(pending[0]!.real);\n        pending.length = 0;\n      }\n    };\n    for (const atom of atoms) {\n      if ('ellipsis' in atom) {\n        flushPending();\n        const ellipsisNode = new CborEllipsis(\n          atom.fromByteLiteral,\n          atom.literalSource\n        );\n        ellipsisNode.start = atom.start;\n        ellipsisNode.end = atom.end;\n        items.push(ellipsisNode);\n        realBoundary.push(atom.real);\n      } else {\n        pending.push(atom);\n      }\n    }\n    flushPending();\n\n    return new CborEllipsis(items, realBoundary);\n  }\n\n  private _concatBytes(parts: Uint8Array[]): Uint8Array {\n    const total = parts.reduce((n, p) => n + p.byteLength, 0);\n    const out = new Uint8Array(total);\n    let off = 0;\n    for (const p of parts) {\n      out.set(p, off);\n      off += p.byteLength;\n    }\n    return out;\n  }\n\n  private parseSimple(): CborSimple {\n    this.t.consume(); // 'simple'\n    this.expect('LPAREN');\n    const numTok = this.t.peek();\n    if (numTok.type !== 'INTEGER')\n      this._fail(\n        `expected integer inside simple(), got ${JSON.stringify(numTok.value)}`,\n        numTok\n      );\n    this.t.consume();\n    const { numStr } = parseIntegerRaw(numTok.value);\n    const n = Number(parseBigInt(numStr));\n    this.expect('RPAREN');\n    return new CborSimple(n, { ednSource: numTok.raw });\n  }\n\n  private parseEmbeddedCBOR(): CborEmbeddedCBOR {\n    this.t.consume(); // <<\n    const items: CborItem[] = [];\n    while (this.t.peek().type !== 'GT_GT') {\n      if (items.length > 0) {\n        if (this.t.peek().type === 'COMMA') {\n          this.t.consume();\n          if (this.t.peek().type === 'GT_GT') break; // trailing comma\n        } else if (this.t.peek().offset === this.t.lastEndOffset) {\n          this._warnOrFail(\n            '<<...>> items must be separated by \",\" or whitespace',\n            this.t.peek()\n          );\n        }\n      }\n      items.push(this.parseValue());\n    }\n    this.expect('GT_GT');\n    let encodingWidth: EncodingWidth | undefined;\n    if (this.t.peek().type === 'ENCODING_INDICATOR') {\n      const eiTok = this.t.consume();\n      encodingWidth = this._resolveEncodingWidth(eiTok.value, eiTok);\n    }\n    return new CborEmbeddedCBOR(items, { encodingWidth });\n  }\n\n  private parseArray(): CborArray {\n    this.t.consume(); // [\n    let indefiniteLength = false;\n    let encodingWidth: EncodingWidth | undefined;\n    let eiTok: Token | undefined;\n    if (this.t.peek().type === 'UNDERSCORE') {\n      this.t.consume();\n      indefiniteLength = true;\n    } else if (this.t.peek().type === 'ENCODING_INDICATOR') {\n      eiTok = this.t.consume();\n      if (eiTok.value === '7') {\n        indefiniteLength = true;\n        const msg =\n          'encoding indicator _7 is non-standard; use _ to indicate indefinite length';\n        this._warnOrFail(msg, eiTok);\n        eiTok = undefined;\n      } else {\n        encodingWidth = this._resolveEncodingWidth(eiTok.value, eiTok);\n      }\n    }\n    // Rescue setup warnings before inner parseValue() calls drain them into child nodes.\n    const setupWarnings = this._pendingWarnings.splice(0);\n    const items: CborItem[] = [];\n    let blankLineBoundary = this.t.lastEndOffset;\n    while (this.t.peek().type !== 'RBRACKET') {\n      if (items.length > 0) {\n        if (this.t.peek().type === 'COMMA') {\n          this.t.consume();\n          if (this.t.peek().type === 'RBRACKET') break; // trailing comma\n        } else if (this.t.peek().offset === this.t.lastEndOffset) {\n          this._warnOrFail(\n            'array items must be separated by \",\" or whitespace',\n            this.t.peek()\n          );\n        }\n      }\n      const item = this.parseValue();\n      if (hasBlankLineBetween(this.t.source, blankLineBoundary, item.start!))\n        item.blankLineBefore = true;\n      blankLineBoundary = item.end!;\n      items.push(item);\n    }\n    this.expect('RBRACKET');\n    if (encodingWidth !== undefined && eiTok !== undefined) {\n      encodingWidth = this._validateEncodingFit(\n        BigInt(items.length),\n        encodingWidth,\n        eiTok\n      );\n      // _validateEncodingFit may add to _pendingWarnings; outer parseValue() flushes those.\n    }\n    const arrayResult = new CborArray(items, {\n      indefiniteLength,\n      encodingWidth,\n    });\n    if (setupWarnings.length > 0) {\n      arrayResult.warnings ??= [];\n      arrayResult.warnings.push(...setupWarnings);\n    }\n    return arrayResult;\n  }\n\n  private parseMap(): CborMap {\n    this.t.consume(); // {\n    let indefiniteLength = false;\n    let encodingWidth: EncodingWidth | undefined;\n    let eiTok: Token | undefined;\n    if (this.t.peek().type === 'UNDERSCORE') {\n      this.t.consume();\n      indefiniteLength = true;\n    } else if (this.t.peek().type === 'ENCODING_INDICATOR') {\n      eiTok = this.t.consume();\n      if (eiTok.value === '7') {\n        indefiniteLength = true;\n        const msg =\n          'encoding indicator _7 is non-standard; use _ to indicate indefinite length';\n        this._warnOrFail(msg, eiTok);\n        eiTok = undefined;\n      } else {\n        encodingWidth = this._resolveEncodingWidth(eiTok.value, eiTok);\n      }\n    }\n    // Rescue setup warnings before inner parseValue() calls drain them into child nodes.\n    const setupWarnings = this._pendingWarnings.splice(0);\n    const entries: [CborItem, CborItem][] = [];\n    let blankLineBoundary = this.t.lastEndOffset;\n    while (this.t.peek().type !== 'RBRACE') {\n      if (entries.length > 0) {\n        if (this.t.peek().type === 'COMMA') {\n          this.t.consume();\n          if (this.t.peek().type === 'RBRACE') break; // trailing comma\n        } else if (this.t.peek().offset === this.t.lastEndOffset) {\n          this._warnOrFail(\n            'map entries must be separated by \",\" or whitespace',\n            this.t.peek()\n          );\n        }\n      }\n      const key = this.parseValue();\n      if (hasBlankLineBetween(this.t.source, blankLineBoundary, key.start!))\n        key.blankLineBefore = true;\n      this.expect('COLON');\n      const val = this.parseValue();\n      blankLineBoundary = val.end!;\n      entries.push([key, val]);\n    }\n    this.expect('RBRACE');\n    if (encodingWidth !== undefined && eiTok !== undefined) {\n      encodingWidth = this._validateEncodingFit(\n        BigInt(entries.length),\n        encodingWidth,\n        eiTok\n      );\n    }\n    const mapResult = new CborMap(entries, { indefiniteLength, encodingWidth });\n    if (setupWarnings.length > 0) {\n      mapResult.warnings ??= [];\n      mapResult.warnings.push(...setupWarnings);\n    }\n    return mapResult;\n  }\n\n  /** Parses `(_ chunk, chunk, ...)` — indefinite byte or text string. */\n  private parseIndefGroup():\n    CborIndefiniteByteString | CborIndefiniteTextString {\n    this.t.consume(); // (\n    const next = this.t.peek();\n    if (next.type === 'UNDERSCORE') {\n      this.t.consume(); // _\n    } else if (next.type === 'ENCODING_INDICATOR' && next.value === '7') {\n      this.t.consume(); // _7 — alias for _, but non-standard\n      const msg7 =\n        'encoding indicator _7 is non-standard; use _ to indicate indefinite length';\n      this._warnOrFail(msg7, next);\n    } else if (next.type === 'ENCODING_INDICATOR') {\n      // _0–_6: not meaningful here; warn and drop, then parse chunks\n      const tok = this.t.consume();\n      const msg = `encoding indicator _${tok.value} is not valid in an indefinite string group; use _`;\n      this._warnOrFail(msg, tok);\n    } else if (next.type !== 'RPAREN') {\n      // No indicator at all — warn that _ is expected, then parse chunks\n      const msg =\n        'indefinite string group is missing _ after (; interpreting as (_ ...)';\n      this._warnOrFail(msg, next);\n      // Do not consume — the next token is the first chunk\n    }\n\n    // Rescue any warnings emitted above from _pendingWarnings before inner\n    // parseValue() calls for each chunk drain them into the wrong node.\n    const setupWarnings = this._pendingWarnings.splice(0);\n\n    const chunks: CborItem[] = [];\n    let blankLineBoundary = this.t.lastEndOffset;\n    while (this.t.peek().type !== 'RPAREN') {\n      if (chunks.length > 0) {\n        if (this.t.peek().type === 'COMMA') {\n          this.t.consume();\n          if (this.t.peek().type === 'RPAREN') break; // trailing comma\n        } else if (this.t.peek().offset === this.t.lastEndOffset) {\n          this._warnOrFail(\n            'indefinite string chunks must be separated by \",\" or whitespace',\n            this.t.peek()\n          );\n        }\n      }\n      const chunk = this.parseValue();\n      if (hasBlankLineBetween(this.t.source, blankLineBoundary, chunk.start!))\n        chunk.blankLineBefore = true;\n      blankLineBoundary = chunk.end!;\n      chunks.push(chunk);\n    }\n    this.expect('RPAREN');\n\n    if (chunks.length === 0)\n      this._fail(\n        'empty indefinite group (_ ) is ambiguous; use \\'\\'_ for bytes or \"\"_ for text'\n      );\n\n    const first = chunks[0];\n    // All chunks must be the same type — mixing byte and text strings is\n    // a SyntaxError per draft §2.5.4.\n    if (first instanceof CborByteString) {\n      const byteChunks = chunks.map((c, i) => {\n        if (c instanceof CborByteString) return c;\n        this._fail(\n          `indefinite byte string chunk ${i} must be a byte string, not a text string`\n        );\n      });\n      const result = new CborIndefiniteByteString(byteChunks);\n      if (setupWarnings.length > 0) result.warnings = setupWarnings;\n      return result;\n    }\n    if (first instanceof CborTextString) {\n      const textChunks = chunks.map((c, i) => {\n        if (c instanceof CborTextString) return c;\n        this._fail(\n          `indefinite text string chunk ${i} must be a text string, not a byte string`\n        );\n      });\n      const result = new CborIndefiniteTextString(textChunks);\n      if (setupWarnings.length > 0) result.warnings = setupWarnings;\n      return result;\n    }\n    this._fail('indefinite group chunks must be byte strings or text strings');\n  }\n\n  // ── Helpers ─────────────────────────────────────────────────────────────\n\n  /**\n   * Consume an ENCODING_INDICATOR token if present.\n   * Validates the indicator type (reserved/indefinite), and when\n   * `getStoredValue` is supplied also checks that the value fits in the\n   * requested encoding width.  The stored value is computed lazily — only\n   * when an indicator is actually present — so callers can pass e.g. a\n   * UTF-8 byte-length computation without paying for it on every string.\n   */\n  private consumeEncodingIndicator(\n    getStoredValue?: () => bigint,\n    onToken?: (token: Token) => void\n  ): EncodingWidth | undefined {\n    if (this.t.peek().type === 'ENCODING_INDICATOR') {\n      const tok = this.t.consume();\n      onToken?.(tok);\n      let ew = this._resolveEncodingWidth(tok.value, tok);\n      if (ew !== undefined && getStoredValue !== undefined) {\n        ew = this._validateEncodingFit(getStoredValue(), ew, tok);\n      }\n      return ew;\n    }\n    return undefined;\n  }\n\n  private expect(type: TokenType): Token {\n    const tok = this.t.consume();\n    if (tok.type !== type)\n      this._fail(\n        `expected ${type}, got ${tok.type} (${JSON.stringify(tok.value)})`,\n        tok\n      );\n    return tok;\n  }\n\n  /**\n   * Validate that `storedValue` fits in the given encoding width.\n   * Returns `ew` if valid; warns and returns `undefined` if not (throws in strict mode).\n   * `storedValue` is the CBOR argument: the integer itself for uint/tag, `abs(n)−1` for nint,\n   * the byte-length for strings, or the item count for arrays/maps.\n   */\n  /** Apply an encoding indicator to a parsed app-string / app-sequence result. */\n  private _applyEiToResult(\n    result: CborItem,\n    ew: EncodingWidth,\n    tok: Token\n  ): void {\n    if (result instanceof CborFloat) {\n      const targetPrec: FloatPrecision | undefined =\n        ew === 1\n          ? 'half'\n          : ew === 2\n            ? 'single'\n            : ew === 3\n              ? 'double'\n              : undefined;\n      if (targetPrec === undefined) {\n        this._warnOrFail(\n          `encoding indicator _${ew} is not valid for a float; use _1, _2, or _3`,\n          tok\n        );\n      } else if (result.precision !== targetPrec) {\n        if (targetPrec !== 'double') {\n          const rt =\n            targetPrec === 'half'\n              ? float16BitsToFloat64(float64ToFloat16Bits(result.value))\n              : Math.fround(result.value);\n          if (!Object.is(rt, result.value) && !isNaN(result.value))\n            this._warnOrFail(\n              `${result.value} cannot be exactly represented as ${targetPrec === 'half' ? 'float16 (_1)' : 'float32 (_2)'}`,\n              tok\n            );\n        }\n        result.precision = targetPrec;\n      }\n    } else if (result instanceof CborUint) {\n      if (result.encodingWidth === undefined) {\n        const ewv = this._validateEncodingFit(result.value, ew, tok);\n        if (ewv !== undefined) result.encodingWidth = ewv;\n      }\n    } else if (result instanceof CborNint) {\n      if (result.encodingWidth === undefined) {\n        const ewv = this._validateEncodingFit(result.argument, ew, tok);\n        if (ewv !== undefined) result.encodingWidth = ewv;\n      }\n    } else if (result instanceof CborByteString) {\n      if (result.encodingWidth === undefined) {\n        const ewv = this._validateEncodingFit(\n          BigInt(result.value.length),\n          ew,\n          tok\n        );\n        if (ewv !== undefined) result.encodingWidth = ewv;\n      }\n    } else if (result instanceof CborTextString) {\n      if (result.encodingWidth === undefined) {\n        const ewv = this._validateEncodingFit(\n          BigInt(textEncoder.encode(result.value).length),\n          ew,\n          tok\n        );\n        if (ewv !== undefined) result.encodingWidth = ewv;\n      }\n    } else if (result instanceof CborArray) {\n      if (result.encodingWidth === undefined) {\n        const ewv = this._validateEncodingFit(\n          BigInt(result.items.length),\n          ew,\n          tok\n        );\n        if (ewv !== undefined) result.encodingWidth = ewv;\n      }\n    } else if (result instanceof CborMap) {\n      if (result.encodingWidth === undefined) {\n        const ewv = this._validateEncodingFit(\n          BigInt(result.entries.length),\n          ew,\n          tok\n        );\n        if (ewv !== undefined) result.encodingWidth = ewv;\n      }\n    } else if (result instanceof CborTag) {\n      // Per draft-ietf-cbor-edn-literals-25 §2.3.1, the EI applies to\n      // the tag number, not to the content (e.g. 1_1(4711) → 2-byte tag).\n      if (result.encodingWidth === undefined) {\n        const ewv = this._validateEncodingFit(result.tag, ew, tok);\n        if (ewv !== undefined) result.encodingWidth = ewv;\n      }\n    } else {\n      this._warnOrFail(\n        `encoding indicator _${ew} is not applicable to this app-string result type`,\n        tok\n      );\n    }\n  }\n\n  private _validateEncodingFit(\n    storedValue: bigint,\n    ew: EncodingWidth,\n    tok: Token\n  ): EncodingWidth | undefined {\n    const max = maxForEncodingWidth(ew);\n    if (storedValue <= max) return ew;\n    const label = ew === 'i' ? '_i (max 23)' : `_${ew} (max ${max})`;\n    const msg = `value ${storedValue} does not fit in encoding indicator ${label}`;\n    this._warnOrFail(msg, tok);\n    return undefined;\n  }\n\n  private _resolveEncodingWidth(\n    raw: string,\n    tok: Token\n  ): EncodingWidth | undefined {\n    if (raw === '4' || raw === '5' || raw === '6') {\n      const ai = Number(raw) + 24; // 28, 29, or 30 — reserved in RFC 8949\n      const msg = `encoding indicator _${raw} (AI ${ai}) is reserved and not valid`;\n      this._warnOrFail(msg, tok);\n      return undefined;\n    }\n    if (raw === '7') {\n      const msg =\n        'indefinite-length encoding (_7) is not valid here; use [_ ...] or {_ ...} for indefinite collections';\n      this._warnOrFail(msg, tok);\n      return undefined;\n    }\n    if (raw === 'i') return 'i';\n    return Number(raw) as EncodingWidth; // '0'–'3' → 0–3\n  }\n\n  /** Builds the onError callback passed to extension parseAppString/parseAppSequence. */\n  private _extOnError(tok: Token): (msg: string) => void {\n    return (msg: string) => this._warnOrFail(msg, tok);\n  }\n\n  /**\n   * Record a strict violation: always emits a ParseWarning, and in strict\n   * mode (the default) also throws a SyntaxError at the token's location.\n   */\n  private _warnOrFail(msg: string, tok?: Token): void {\n    this._warn(msg, tok);\n    if (this._options.strict !== false) this._fail(msg, tok);\n  }\n\n  /**\n   * Emit a one-time, non-fatal hint when a known opt-in extension prefix\n   * (b32, h32, float, same, hash, uuid) is used without the corresponding\n   * extension registered. Never throws and does not attach node warnings;\n   * parsing continues with the usual unresolved-extension handling.\n   */\n  private _hintMissingExtension(prefix: string, tok: Token): void {\n    const hint = MISSING_EXTENSION_HINTS.get(prefix);\n    if (hint === undefined || this._hintedPrefixes.has(prefix)) return;\n    this._hintedPrefixes.add(prefix);\n    const message = `app-string prefix '${prefix}' requires an extension that is not enabled; ${hint}`;\n    if (this._options.onWarning) {\n      this._options.onWarning({ message, ...tokenPosition(tok), hint: true });\n    } else if (!this._options.silent) {\n      console.warn(`CDN: ${message}`);\n    }\n  }\n\n  private _warn(msg: string, tok?: Token): void {\n    const warning: ParseWarning = { message: msg };\n    if (tok !== undefined) Object.assign(warning, tokenPosition(tok));\n    this._pendingWarnings.push(warning);\n    if (this._options.onWarning) {\n      this._options.onWarning(warning);\n    } else if (!this._options.silent) {\n      const loc = tok ? ` at line ${tok.line}, column ${tok.col}` : '';\n      console.warn(`CDN strict violation${loc}: ${msg}`);\n    }\n  }\n\n  private _fail(msg: string, tok?: Token): never {\n    throw new CdnSyntaxError(msg, tok ? tokenPosition(tok) : undefined);\n  }\n}\n\n/** A token's source position in the shape shared by ParseWarning and CdnSyntaxError. */\nfunction tokenPosition(tok: Token): {\n  offset: number;\n  line: number;\n  column: number;\n  endOffset: number;\n} {\n  return {\n    offset: tok.offset,\n    line: tok.line,\n    column: tok.col,\n    endOffset: tok.endOffset,\n  };\n}\n","import type {\n  ToCDNOptions,\n  ToJSOptions,\n  ToCBOROptions,\n  CborComment,\n} from '../types';\nimport { CborItem } from './CborItem';\nimport { MT_TEXT } from '../cbor/constants';\nimport type { CborWriter, EncodingWidth } from '../cbor/encode';\nimport { parseCDN } from '../cdn/parser';\n// Internal lexer reuse: parseCDN() validates embedded CDN first; this pass\n// only needs token offsets so string formatting can split without changing text.\nimport { Tokenizer, type TokenType } from '../cdn/tokenizer';\nimport {\n  escapeString,\n  indentOf,\n  resolveIndent,\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n  danglingCommentsByGap,\n} from '../cdn/serialize-utils';\n\nconst textEncoder = new TextEncoder();\nlet didWarnCborEdnTextStringFormat = false;\n\n/** CBOR Major Type 3 — definite-length UTF-8 text string. */\nexport class CborTextString extends CborItem {\n  readonly indefiniteLength = false as const;\n  readonly value: string;\n  encodingWidth: EncodingWidth | undefined;\n  /** Part boundaries of the original `+` concatenation chain, if any. */\n  readonly ednParts: readonly string[] | undefined;\n  /** Original raw-string source text, when parsed from a single backtick literal. */\n  readonly ednSource: string | undefined;\n  /**\n   * Original double-quoted source text (including its escape sequences),\n   * when parsed from a single non-concatenated `\"...\"` literal. Used by\n   * `_toCDN()` to round-trip the literal's exact spelling when\n   * `preserveTextString` is set.\n   */\n  readonly quotedEdnSource: string | undefined;\n  /**\n   * Original source text per `ednParts` entry, aligned by index; `undefined`\n   * for parts that were not raw backtick literals.\n   */\n  readonly ednPartSources: readonly (string | undefined)[] | undefined;\n  /**\n   * `true` at index `i`, aligned with `ednParts`, when that part came from a\n   * byte-string literal on the right of a text-leading `+` concatenation\n   * (decoded as UTF-8 and merged in per §5.1) rather than a double-quoted\n   * `\"...\"` literal. Both cases leave `ednPartSources[i]` `undefined` (byte\n   * strings have no preserved raw source here, same as an unpreserved\n   * double-quoted literal), so this is what lets `appSeqSourceFeatures`\n   * attribute the part to `byteString` instead of the unpreservable\n   * `textString`.\n   */\n  readonly ednPartIsByteString: readonly boolean[] | undefined;\n  /**\n   * Source span of each `ednParts` entry's own literal token, aligned by\n   * index — used to place a comment sitting between two `+`-joined parts at\n   * the right gap instead of dropping it (there is no per-part AST node for\n   * such a comment to attach to; it lands as `dangling` on this whole node\n   * instead — see `CborByteString.ednParts`'s equivalent doc). `undefined`\n   * for a node not parsed from a `+` chain at all.\n   */\n  readonly ednPartSpans: readonly { start: number; end: number }[] | undefined;\n\n  constructor(\n    value: string,\n    options?: {\n      encodingWidth?: EncodingWidth;\n      ednParts?: readonly string[];\n      ednSource?: string;\n      quotedEdnSource?: string;\n      ednPartSources?: readonly (string | undefined)[];\n      ednPartIsByteString?: readonly boolean[];\n      ednPartSpans?: readonly { start: number; end: number }[];\n    }\n  ) {\n    super();\n    this.value = value;\n    this.encodingWidth = options?.encodingWidth;\n    this.ednParts = options?.ednParts;\n    this.ednSource = options?.ednSource;\n    this.quotedEdnSource = options?.quotedEdnSource;\n    this.ednPartSources = options?.ednPartSources;\n    this.ednPartIsByteString = options?.ednPartIsByteString;\n    this.ednPartSpans = options?.ednPartSpans;\n  }\n\n  override _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void {\n    writer.writeTextString(MT_TEXT, this.value, this.encodingWidth);\n  }\n\n  _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    const suffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(BigInt(textEncoder.encode(this.value).length))\n    );\n    return formatTextString(\n      this.value,\n      suffix,\n      options,\n      depth,\n      this.ednParts,\n      this.ednSource,\n      this.quotedEdnSource,\n      this.ednPartSources,\n      this.ednPartSpans,\n      this.comments?.dangling\n    );\n  }\n\n  _toJS(_options?: ToJSOptions): unknown {\n    return this.value;\n  }\n}\n\nfunction formatTextString(\n  value: string,\n  suffix: string,\n  options: ToCDNOptions | undefined,\n  depth: number,\n  ednParts: readonly string[] | undefined,\n  ednSource: string | undefined,\n  quotedEdnSource: string | undefined,\n  ednPartSources: readonly (string | undefined)[] | undefined,\n  ednPartSpans: readonly { start: number; end: number }[] | undefined,\n  dangling: readonly CborComment[] | undefined\n): string {\n  const indentStr = resolveIndent(options);\n  // A preserved raw backtick literal is emitted verbatim — re-escaping,\n  // re-indenting, or splitting it would change its meaning or its\n  // deliberately chosen form. In single-line mode a spelling that spans\n  // multiple lines (raw strings are often written that way) cannot be\n  // re-emitted, so it falls back to normal escaping instead.\n  if (\n    options?.preserveRawString &&\n    ednSource !== undefined &&\n    (indentStr !== null || !/[\\r\\n]/.test(ednSource))\n  ) {\n    return ednSource + suffix;\n  }\n  // Likewise for a preserved double-quoted literal: keep its original\n  // escape-sequence spelling instead of re-escaping the decoded value.\n  if (\n    options?.preserveTextString &&\n    quotedEdnSource !== undefined &&\n    (indentStr !== null || !/[\\r\\n]/.test(quotedEdnSource))\n  ) {\n    return quotedEdnSource + suffix;\n  }\n  // Splits and preserved concatenation are layout features, disabled in\n  // single-line mode: the string collapses to one literal.\n  if (indentStr === null) {\n    return escapeString(value) + suffix;\n  }\n  const partSources = options?.preserveRawString ? ednPartSources : undefined;\n  const hasPreservedRawPart =\n    partSources?.some((source) => source !== undefined) ?? false;\n  const { cdn, newline } = resolveTextStringSplits(options);\n  const preservedParts =\n    options?.preserveConcatenation &&\n    ednParts !== undefined &&\n    (ednParts.length > 1 || hasPreservedRawPart)\n      ? ednParts\n      : undefined;\n\n  if (!cdn && !newline && preservedParts === undefined) {\n    return escapeString(value) + suffix;\n  }\n\n  const cdnBreakpoints = cdn ? collectCdnBreakpoints(value) : null;\n\n  // Preserved concatenation applies unless CDN reflow is applicable (the\n  // string content parses as CDN — then structure-aware indentation wins).\n  // A preserved raw part takes precedence over CDN reflow because changing\n  // its spelling would violate preserveRawString. `splitNewline` combines\n  // with this path by further splitting only the non-raw parts.\n  if (\n    preservedParts !== undefined &&\n    (cdnBreakpoints === null || hasPreservedRawPart)\n  ) {\n    // A comment between two `+`-joined parts has no per-part AST node of\n    // its own to attach to — it lands as `dangling` on this whole node\n    // instead (see `ednPartSpans`'s doc) — so re-derive which gap each one\n    // belongs to from each part's own source span.\n    const gapComments = options?.preserveComments\n      ? danglingCommentsByGap(\n          dangling,\n          ednPartSpans,\n          typeof options.preserveComments === 'string'\n            ? options.preserveComments\n            : undefined\n        )\n      : undefined;\n    const parts: StringPart[] = [];\n    for (const [i, text] of preservedParts.entries()) {\n      const source = partSources?.[i];\n      if (source !== undefined) {\n        parts.push({ text, contentDepth: 0, source });\n      } else if (newline) {\n        const partBreakpoints = new Map<number, number>();\n        for (const { point, contentDepth } of collectNewlineBreakpoints(\n          text,\n          0\n        )) {\n          partBreakpoints.set(point, contentDepth);\n        }\n        parts.push(...splitAtBreakpoints(text, partBreakpoints));\n      } else {\n        parts.push({ text, contentDepth: 0 });\n      }\n      // Whichever output part `text` ended up split into, the comment for\n      // the gap right after it (if any) belongs on the last one — the true\n      // `+` boundary to the next preserved part sits right there.\n      const comments = gapComments?.[i];\n      if (comments && comments.length > 0) {\n        parts[parts.length - 1]!.commentsAfter = comments;\n      }\n    }\n    return emitParts(parts, suffix, indentStr, depth);\n  }\n\n  const breakpoints = new Map<number, number>();\n  if (cdnBreakpoints !== null) {\n    for (const { point, contentDepth } of cdnBreakpoints) {\n      breakpoints.set(point, contentDepth);\n    }\n  }\n  if (newline) {\n    const newlineBreakpoints =\n      cdnBreakpoints !== null\n        ? collectCdnNewlineBreakpoints(value)\n        : collectNewlineBreakpoints(value, 0);\n    for (const { point, contentDepth } of newlineBreakpoints) {\n      if (!breakpoints.has(point)) {\n        breakpoints.set(point, contentDepth);\n      }\n    }\n  }\n\n  const parts = splitAtBreakpoints(value, breakpoints);\n  if (parts.length <= 1) return escapeString(value) + suffix;\n  return emitParts(parts, suffix, indentStr, depth);\n}\n\n/**\n * Serialize string parts as a `+` concatenation chain, one part per\n * continuation line indented by `depth + 1 + contentDepth`.  The EI suffix\n * is appended to the last part. Only reached in multi-line mode — preserved\n * concatenation is disabled in single-line output.\n */\nfunction emitParts(\n  parts: readonly StringPart[],\n  suffix: string,\n  indentStr: string,\n  depth: number\n): string {\n  const literals = parts.map(({ text, source }, i) => {\n    const literal = source ?? escapeString(text);\n    return i === parts.length - 1 ? literal + suffix : literal;\n  });\n  let result = literals[0]!;\n  for (let i = 1; i < literals.length; i++) {\n    const continuationIndent = indentOf(\n      indentStr,\n      depth + 1 + parts[i]!.contentDepth\n    );\n    result += ' +\\n';\n    for (const comment of parts[i - 1]!.commentsAfter ?? []) {\n      result += `${continuationIndent}${comment}\\n`;\n    }\n    result += `${continuationIndent}${literals[i]}`;\n  }\n  return result;\n}\n\n/**\n * Resolve the effective split strategies from `splitCdn` / `splitNewline`,\n * falling back per-field to the deprecated array-valued `textStringFormat`.\n */\nfunction resolveTextStringSplits(options: ToCDNOptions | undefined): {\n  cdn: boolean;\n  newline: boolean;\n} {\n  const formats =\n    options?.splitCdn === undefined || options?.splitNewline === undefined\n      ? normalizeTextStringFormats(options?.textStringFormat ?? [])\n      : [];\n  return {\n    cdn: options?.splitCdn ?? formats.includes('cdn'),\n    newline: options?.splitNewline ?? formats.includes('newline'),\n  };\n}\n\nfunction normalizeTextStringFormats(\n  formats: NonNullable<ToCDNOptions['textStringFormat']>\n): ('newline' | 'cdn')[] {\n  return formats.map((format) => {\n    if (format !== 'cboredn') return format;\n    if (!didWarnCborEdnTextStringFormat) {\n      didWarnCborEdnTextStringFormat = true;\n      console.warn(\n        \"`textStringFormat: ['cboredn']` is deprecated; use `textStringFormat: ['cdn']` instead.\"\n      );\n    }\n    return 'cdn';\n  });\n}\n\ninterface StringBreakpoint {\n  point: number;\n  contentDepth: number;\n}\n\ninterface StringPart {\n  text: string;\n  contentDepth: number;\n  /** Preserved literal source; emitted verbatim instead of escaping `text`. */\n  source?: string;\n  /**\n   * Already-converted comment text that sat right after this part in the\n   * source — a genuine `+` boundary this part precedes, not a further split\n   * of the same original preserved part — emitted by `emitParts` right\n   * before the next part.\n   */\n  commentsAfter?: string[];\n}\n\nfunction collectNewlineBreakpoints(\n  value: string,\n  contentDepth: number\n): StringBreakpoint[] {\n  const points: StringBreakpoint[] = [];\n  for (let i = 0; i < value.length; i++) {\n    const ch = value[i];\n    if (ch === '\\r') {\n      if (value[i + 1] === '\\n') {\n        points.push({ point: i + 2, contentDepth });\n        i++;\n      } else {\n        points.push({ point: i + 1, contentDepth });\n      }\n    } else if (ch === '\\n') {\n      points.push({ point: i + 1, contentDepth });\n    }\n  }\n  return points;\n}\n\nfunction collectCdnBreakpoints(value: string): StringBreakpoint[] | null {\n  try {\n    parseCDN(value);\n  } catch {\n    return null;\n  }\n\n  // The parse above validates structure. This second tokenizer pass only\n  // collects original-source offsets and nesting depth for non-mutating splits.\n  const points: StringBreakpoint[] = [];\n  const tokenizer = new Tokenizer(value);\n  let nesting = 0;\n  let pending: {\n    point: number;\n    contentDepth: number;\n    kind: 'opener' | 'comma';\n  } | null = null;\n  let sawToken = false;\n  let lastTokenEnd = 0;\n  for (;;) {\n    const token = tokenizer.consume();\n    if (token.type === 'EOF') break;\n    let skipClosePoint = false;\n\n    if (!sawToken) {\n      sawToken = true;\n      if (\n        token.offset > 0 &&\n        hasCommentBetween(tokenizer.comments, 0, token.offset)\n      ) {\n        points.push({ point: token.offset, contentDepth: nesting });\n      }\n    }\n\n    // After an opener/comma, split before the next token so intervening layout\n    // whitespace stays at the end of the previous chunk.\n    if (pending !== null) {\n      if (pending.kind === 'opener' && OPENER_MODIFIER_TOKENS.has(token.type)) {\n        pending.point = token.endOffset;\n        lastTokenEnd = token.endOffset;\n        continue;\n      } else if (\n        pending.kind === 'opener' &&\n        CLOSE_TOKENS.has(token.type) &&\n        hasOnlyWhitespaceBetween(value, pending.point, token.offset)\n      ) {\n        skipClosePoint = true;\n      } else {\n        points.push({\n          point: token.offset,\n          contentDepth: pending.contentDepth,\n        });\n      }\n      pending = null;\n    }\n\n    if (OPEN_TOKENS.has(token.type)) {\n      nesting++;\n      pending = {\n        point: token.endOffset,\n        contentDepth: nesting,\n        kind: 'opener',\n      };\n    } else if (CLOSE_TOKENS.has(token.type)) {\n      nesting = Math.max(0, nesting - 1);\n      if (!skipClosePoint) {\n        points.push({ point: token.offset, contentDepth: nesting });\n      }\n    } else if (token.type === 'COMMA') {\n      pending = {\n        point: token.endOffset,\n        contentDepth: nesting,\n        kind: 'comma',\n      };\n    }\n    lastTokenEnd = token.endOffset;\n  }\n\n  const trailingComment = tokenizer.comments.find(\n    (comment) => comment.start >= lastTokenEnd\n  );\n  if (trailingComment !== undefined) {\n    points.push({ point: trailingComment.start, contentDepth: nesting });\n  }\n  return points;\n}\n\nfunction collectCdnNewlineBreakpoints(value: string): StringBreakpoint[] {\n  const points: StringBreakpoint[] = [];\n  const tokenizer = new Tokenizer(value);\n  let nesting = 0;\n  for (;;) {\n    const token = tokenizer.consume();\n    if (token.type === 'EOF') break;\n\n    if (OPEN_TOKENS.has(token.type)) {\n      nesting++;\n    } else if (CLOSE_TOKENS.has(token.type)) {\n      nesting = Math.max(0, nesting - 1);\n    } else if (token.type === 'COMMA') {\n      // Commas can create structural split points, but never contain newline\n      // split points themselves.\n    } else if (token.type === 'TSTR') {\n      // TSTR uses escape sequences (\\n, \\r) for newlines in addition to\n      // literal newline characters.\n      const tokenText = value.slice(token.offset, token.endOffset);\n      for (const point of collectTstrNewlineBreakpoints(tokenText)) {\n        points.push({ point: token.offset + point, contentDepth: nesting + 1 });\n      }\n    } else if (token.type === 'RAWSTRING') {\n      // RAWSTRING has no escape sequences; only literal newlines apply.\n      const tokenText = value.slice(token.offset, token.endOffset);\n      for (const { point } of collectNewlineBreakpoints(tokenText, 0)) {\n        points.push({ point: token.offset + point, contentDepth: nesting + 1 });\n      }\n    }\n  }\n  return points;\n}\n\n// Scans the raw source of a CDN double-quoted string (TSTR) for newline\n// escape sequences (\\n, \\r) and literal newline characters, returning the\n// position within tokenText immediately after each such sequence.\nfunction collectTstrNewlineBreakpoints(tokenText: string): number[] {\n  const points: number[] = [];\n  let i = 1; // skip opening \"\n  const end = tokenText.length - 1; // stop before closing \"\n  while (i < end) {\n    const ch = tokenText[i];\n    if (ch === '\\\\') {\n      const next = tokenText[i + 1];\n      if (next === 'n' || next === 'r') {\n        points.push(i + 2);\n        i += 2;\n      } else if (next === 'u') {\n        if (tokenText[i + 2] === '{') {\n          const close = tokenText.indexOf('}', i + 3);\n          i = close >= 0 ? close + 1 : i + 2;\n        } else {\n          i += 6; // \\uXXXX\n        }\n      } else {\n        i += 2; // \\\\, \\\", \\t, etc.\n      }\n    } else if (ch === '\\r') {\n      if (tokenText[i + 1] === '\\n') {\n        points.push(i + 2);\n        i += 2;\n      } else {\n        points.push(i + 1);\n        i++;\n      }\n    } else if (ch === '\\n') {\n      points.push(i + 1);\n      i++;\n    } else {\n      i++;\n    }\n  }\n  return points;\n}\n\nconst OPENER_MODIFIER_TOKENS = new Set<TokenType>([\n  'ENCODING_INDICATOR',\n  'UNDERSCORE',\n]);\n\nconst OPEN_TOKENS = new Set<TokenType>([\n  'LBRACKET',\n  'LBRACE',\n  'LPAREN',\n  'LT_LT',\n]);\n\nconst CLOSE_TOKENS = new Set<TokenType>([\n  'RBRACKET',\n  'RBRACE',\n  'RPAREN',\n  'GT_GT',\n]);\n\nfunction hasCommentBetween(\n  comments: readonly { start: number; end: number }[],\n  start: number,\n  end: number\n): boolean {\n  // Comments use half-open source ranges; this checks for comments wholly\n  // contained in [start, end), including one that ends exactly at `end`.\n  return comments.some(\n    (comment) => comment.start >= start && comment.end <= end\n  );\n}\n\nfunction hasOnlyWhitespaceBetween(\n  value: string,\n  start: number,\n  end: number\n): boolean {\n  return /^[\\t\\n\\r ]*$/.test(value.slice(start, end));\n}\n\nfunction splitAtBreakpoints(\n  value: string,\n  breakpoints: Map<number, number>\n): StringPart[] {\n  const points = [...breakpoints]\n    .filter(([point]) => point > 0 && point < value.length)\n    .sort(([a], [b]) => a - b);\n  if (points.length === 0) return [{ text: value, contentDepth: 0 }];\n\n  const parts: StringPart[] = [];\n  let start = 0;\n  let contentDepth = 0;\n  for (const [point, nextContentDepth] of points) {\n    if (point === start) continue;\n    parts.push({ text: value.slice(start, point), contentDepth });\n    start = point;\n    contentDepth = nextContentDepth;\n  }\n  if (start < value.length) {\n    parts.push({ text: value.slice(start), contentDepth });\n  }\n  return parts;\n}\n","/**\n * Standard CDN \"dt\" / \"DT\" application-extension (§3.1 of draft-ietf-cbor-edn-literals-25).\n *\n * Parses RFC 3339 date-time app-strings into epoch-based numeric CBOR values.\n * The resulting CborItem subclasses override toCDN() so the value round-trips\n * back to dt'...' / DT'...' notation.\n *\n * For a richer variant that makes toJS() return Date objects, use dt_as_Date\n * from ./date instead.\n */\n\nimport type { ToCDNOptions, ToJSOptions, FromJSOptions } from '../types';\nimport type { CborExtension } from './types';\nimport type { CborItem } from '../ast/CborItem';\nimport { CborUint } from '../ast/CborUint';\nimport { CborNint } from '../ast/CborNint';\nimport { CborFloat } from '../ast/CborFloat';\nimport { CborTag } from '../ast/CborTag';\nimport type { EncodingWidth } from '../cbor/encode';\nimport { autoSelectFloatPrecision } from '../cbor/encode';\nimport { CborTextString } from '../ast/CborTextString';\nimport { CborByteString } from '../ast/CborByteString';\nimport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n  floatSuffix,\n  decideTaggedAppSeqRendering,\n  adjustRawAppSeqSource,\n  adjustAppSeqIndicator,\n} from '../cdn/serialize-utils';\n\n// ─── Helpers ──────────────────────────────────────────────────────────────────\n\n/**\n * Convert epoch seconds to an RFC 3339 string with appropriate precision.\n *\n * - Integer epoch          → \"…Z\"           (no fractional part)\n * - Millisecond-precision  → \"….SSSZ\"       (3 decimal places, e.g. \".500Z\")\n * - Sub-millisecond        → \"….S…Z\"        (minimal digits, e.g. \".0001Z\")\n *\n * Millisecond precision is used whenever `Math.round(epochSeconds * 1000)`\n * round-trips back to the same float64 value, which is the common case for\n * timestamps stored as integer milliseconds (the JavaScript Date range).\n * Otherwise the shortest decimal representation of the fractional seconds is\n * used so that the float64 value is faithfully represented.\n */\nexport function epochToRfc3339(epochSeconds: number): string {\n  if (Number.isInteger(epochSeconds))\n    return new Date(epochSeconds * 1000).toISOString().replace(/\\.000Z$/, 'Z');\n\n  // Check if millisecond precision suffices (the common case).\n  const roundedMs = Math.round(epochSeconds * 1000);\n  if (roundedMs / 1000 === epochSeconds)\n    return new Date(roundedMs).toISOString().replace(/\\.000Z$/, 'Z');\n\n  // Sub-millisecond precision: decompose into whole seconds + fractional part.\n  // Math.floor ensures the fractional part is always in [0, 1), which is\n  // correct for negative epochs too (e.g. -0.5 → floor=-1, frac=0.5).\n  const wholeSeconds = Math.floor(epochSeconds);\n  const frac = epochSeconds - wholeSeconds;\n\n  // Base timestamp formatted to the second, without any fractional part.\n  const base = new Date(wholeSeconds * 1000)\n    .toISOString()\n    .replace(/\\.\\d+Z$/, '');\n\n  // Minimal decimal representation of the fractional seconds (JavaScript's\n  // Number.prototype.toString uses the shortest round-trip string).\n  const fracStr = frac.toString(); // e.g. \"0.0001\" or \"0.123456\"\n  const dotIdx = fracStr.indexOf('.');\n  let decDigits = dotIdx >= 0 ? fracStr.slice(dotIdx + 1) : '0';\n  // Ensure at least 3 decimal places for conventional readability.\n  while (decDigits.length < 3) decDigits += '0';\n\n  return `${base}.${decDigits}Z`;\n}\n\n/**\n * Extract a date-time string from a single-item app-sequence.\n * Accepts CborTextString (dt<<\"...\">> ) and CborByteString (dt<<'...'>> , UTF-8).\n */\nconst utf8Strict = new TextDecoder('utf-8', { fatal: true });\n\nfunction stringFromAppSequence(items: CborItem[]): string {\n  if (items.length !== 1)\n    throw new SyntaxError('dt<<...>>: expected exactly one item');\n  const item = items[0];\n  if (item instanceof CborTextString) return item.value;\n  if (item instanceof CborByteString) return utf8Strict.decode(item.value);\n  throw new SyntaxError('dt<<...>>: expected a text string or byte string');\n}\n\n/**\n * Parse an RFC 3339 string and produce the appropriate epoch CborItem subclass.\n * Integer seconds → CborEpochDtExtUint or CborEpochDtExtNint.\n * Fractional seconds → CborEpochDtExtFloat.\n *\n * Fractional seconds are extracted from the string directly (via parseFloat)\n * before passing the remainder to Date.parse, so sub-millisecond precision\n * is preserved rather than being rounded to the nearest millisecond.\n */\n// RFC 3339 §5.6: date-time = full-date \"T\" full-time, where full-time requires\n// an offset (Z or ±HH:MM).  Anything shorter is rejected before Date.parse().\nconst RFC3339_RE =\n  /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$/i;\n\nexport function parseDtAppString(\n  str: string,\n  onError?: (msg: string) => void\n): CborEpochDtExtUint | CborEpochDtExtNint | CborEpochDtExtFloat {\n  if (!RFC3339_RE.test(str)) {\n    const msg = `dt: invalid RFC 3339 date-time: ${JSON.stringify(str)}`;\n    if (onError) onError(msg);\n    else throw new SyntaxError(msg);\n  }\n\n  // Separate the fractional-seconds part (if any) from the rest of the string.\n  // This avoids Date.parse() truncating to millisecond precision.\n  // Pattern: ...THH:MM:SS(.frac)(Z|±HH:MM)\n  const fracMatch = str.match(\n    /^(.+T\\d{2}:\\d{2}:\\d{2})(\\.\\d+)(Z|[+-]\\d{2}:\\d{2})$/i\n  );\n\n  let wholeStr: string;\n  let fracValue: number | undefined;\n\n  if (fracMatch) {\n    // Parse the integer-seconds part (without the fractional digits).\n    wholeStr = fracMatch[1] + fracMatch[3];\n    // Parse the fractional seconds string with full float64 precision.\n    fracValue = parseFloat('0' + fracMatch[2]); // e.g. parseFloat(\"0.0001\")\n  } else {\n    wholeStr = str;\n    fracValue = undefined;\n  }\n\n  const ms = Date.parse(wholeStr);\n  if (isNaN(ms))\n    throw new SyntaxError(\n      `dt: invalid RFC 3339 date-time: ${JSON.stringify(str)}`\n    );\n\n  if (fracValue === undefined) {\n    const seconds = ms / 1000;\n    if (seconds >= 0) return new CborEpochDtExtUint(BigInt(seconds));\n    return new CborEpochDtExtNint(BigInt(seconds));\n  }\n\n  return new CborEpochDtExtFloat(ms / 1000 + fracValue);\n}\n\n// ─── Constants ────────────────────────────────────────────────────────────────\n\nexport const PREFIX_DT = 'dt';\nexport const PREFIX_DT_TAGGED = 'DT';\nexport const TAG_EPOCH = 1n;\n\n// ─── CborItem subclasses ─────────────────────────────────────────────────────\n\n/**\n * Unsigned epoch timestamp whose toCDN() emits dt'…' notation.\n * The RFC 3339 string is re-derived from the numeric value on each call.\n */\nexport class CborEpochDtExtUint extends CborUint {\n  constructor(\n    value: number | bigint,\n    options?: { encodingWidth?: EncodingWidth; ednSource?: string }\n  ) {\n    super(value, options);\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, _depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, _depth);\n    const eiSuffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(this.value)\n    );\n    const decision = decideTaggedAppSeqRendering(\n      options,\n      this.appSeqSource,\n      undefined,\n      this.appSeqSourceFeatures\n    );\n    if (decision === 'adjusted')\n      return adjustAppSeqIndicator(\n        this.appSeqSource!,\n        eiSuffix,\n        options,\n        this.appSeqInnerEnd,\n        this.appSeqComments\n      );\n    return `${PREFIX_DT}'${epochToRfc3339(Number(this.value))}'${eiSuffix}`;\n  }\n}\n\n/**\n * Negative epoch timestamp whose toCDN() emits dt'…' notation.\n * The RFC 3339 string is re-derived from the numeric value on each call.\n */\nexport class CborEpochDtExtNint extends CborNint {\n  constructor(\n    value: number | bigint,\n    options?: { encodingWidth?: EncodingWidth; ednSource?: string }\n  ) {\n    super(value, options);\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, _depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, _depth);\n    const eiSuffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(this.argument)\n    );\n    const decision = decideTaggedAppSeqRendering(\n      options,\n      this.appSeqSource,\n      undefined,\n      this.appSeqSourceFeatures\n    );\n    if (decision === 'adjusted')\n      return adjustAppSeqIndicator(\n        this.appSeqSource!,\n        eiSuffix,\n        options,\n        this.appSeqInnerEnd,\n        this.appSeqComments\n      );\n    return `${PREFIX_DT}'${epochToRfc3339(Number(this.value))}'${eiSuffix}`;\n  }\n}\n\n/**\n * Float epoch timestamp whose toCDN() emits dt'…' notation.\n * The RFC 3339 string is re-derived from the numeric value on each call.\n */\nexport class CborEpochDtExtFloat extends CborFloat {\n  constructor(\n    value: number,\n    options?: {\n      precision?: 'half' | 'single' | 'double';\n      literalSource?: string;\n    }\n  ) {\n    super(value, options);\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, _depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, _depth);\n    const autoSelected = autoSelectFloatPrecision(this.value);\n    const eiSuffix = floatSuffix(\n      this.value,\n      this.precision,\n      autoSelected,\n      options?.encodingIndicators ?? 'auto'\n    );\n    const decision = decideTaggedAppSeqRendering(\n      options,\n      this.appSeqSource,\n      undefined,\n      this.appSeqSourceFeatures\n    );\n    if (decision === 'adjusted')\n      return adjustAppSeqIndicator(\n        this.appSeqSource!,\n        eiSuffix,\n        options,\n        this.appSeqInnerEnd,\n        this.appSeqComments\n      );\n    return `${PREFIX_DT}'${epochToRfc3339(this.value)}'${eiSuffix}`;\n  }\n}\n\n/**\n * CBOR tag(1, epoch) whose toCDN() emits DT'…' notation.\n * The RFC 3339 string is re-derived from the numeric content on each call.\n */\nexport class CborTaggedEpochDtExt extends CborTag {\n  constructor(\n    datetimeOrContent:\n      string | CborEpochDtExtUint | CborEpochDtExtNint | CborEpochDtExtFloat,\n    options?: { encodingWidth?: EncodingWidth }\n  ) {\n    super(\n      TAG_EPOCH,\n      typeof datetimeOrContent === 'string'\n        ? parseDtAppString(datetimeOrContent)\n        : datetimeOrContent,\n      options\n    );\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, depth);\n    const decision = decideTaggedAppSeqRendering(\n      options,\n      this.appSeqSource,\n      this.ednSource,\n      this.appSeqSourceFeatures,\n      this.appSeqEncodingEditsComplete\n    );\n    if (decision === 'verbatim') return this.appSeqSource!;\n    if (decision === 'source')\n      return adjustRawAppSeqSource(\n        this.appSeqSource!,\n        options,\n        this.appSeqComments,\n        this.appSeqEncodingEdits\n      );\n    if (decision === 'structural')\n      return super._toCDN({ ...options, appStrings: false }, depth);\n    const eiSuffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(TAG_EPOCH)\n    );\n    if (decision === 'adjusted')\n      return adjustAppSeqIndicator(\n        this.appSeqSource!,\n        eiSuffix,\n        options,\n        this.appSeqInnerEnd,\n        this.appSeqComments\n      );\n    // Per §2.3.1, DT'...'_N encodes only the tag number's width.\n    // If the inner content has non-canonical encoding, fall back to generic tag\n    // notation so the inner EI (e.g. dt'...'_3) is not silently discarded.\n    const c = this.content as\n      CborEpochDtExtUint | CborEpochDtExtNint | CborEpochDtExtFloat;\n    const innerIsNonCanonical =\n      c instanceof CborFloat\n        ? c.precision !== undefined &&\n          c.precision !== autoSelectFloatPrecision(c.value)\n        : (c as CborUint | CborNint).encodingWidth !== undefined;\n    if (innerIsNonCanonical)\n      return super._toCDN({ ...options, appStrings: false }, depth);\n    const epochSec = c instanceof CborFloat ? c.value : Number(c.value);\n    return `${PREFIX_DT_TAGGED}'${epochToRfc3339(epochSec)}'${eiSuffix}`;\n  }\n}\n\n/**\n * CBOR tag(1, epoch) whose toJS() returns a plain Date object.\n * Use dt_as_Date (or createDtExtension({ jsDate: true })) to produce these nodes.\n */\nexport class CborTaggedEpochDtAsDateExt extends CborTaggedEpochDtExt {\n  constructor(\n    datetimeOrContent:\n      string | CborEpochDtExtUint | CborEpochDtExtNint | CborEpochDtExtFloat,\n    options?: { encodingWidth?: EncodingWidth }\n  ) {\n    super(datetimeOrContent, options);\n  }\n\n  override _toJS(_options?: ToJSOptions): Date {\n    const c = this.content as\n      CborEpochDtExtUint | CborEpochDtExtNint | CborEpochDtExtFloat;\n    const epochMs =\n      c instanceof CborFloat ? c.value * 1000 : Number(c.value) * 1000;\n    return new Date(epochMs);\n  }\n}\n\n// ─── Factory ──────────────────────────────────────────────────────────────────\n\n/**\n * Create a dt/DT CborExtension.\n *\n * - `createDtExtension()` — tagged DT values produce `CborTaggedEpochDtExt`;\n *   toJS() returns a number (epoch seconds).\n * - `createDtExtension({ jsDate: true })` — tagged DT values produce\n *   `CborTaggedEpochDtAsDateExt`; toJS() returns a `Date` object, and\n *   `fromJS(Date)` converts `Date` instances back to tagged epoch values.\n */\nexport function createDtExtension(options?: {\n  jsDate?: boolean;\n}): CborExtension {\n  const useDate = options?.jsDate ?? false;\n\n  function makeTagged(\n    datetime: string\n  ): CborTaggedEpochDtExt | CborTaggedEpochDtAsDateExt {\n    return useDate\n      ? new CborTaggedEpochDtAsDateExt(datetime)\n      : new CborTaggedEpochDtExt(datetime);\n  }\n\n  const ext: CborExtension = {\n    appStringPrefixes: [PREFIX_DT, PREFIX_DT_TAGGED],\n    tagNumbers: [TAG_EPOCH],\n    // dt/DT results always have a dedicated subclass (CborEpochDtExt* /\n    // CborTaggedEpochDtExt) that regenerates its notation by default;\n    // 'optional' preserves the <<...>> spelling only when\n    // ToCDNOptions.preserveAppSequence is set, without changing the\n    // returned node's class/identity (see preservedAppSeqSpelling above).\n    preserveAppSeqSource: 'optional',\n\n    parseAppString(\n      prefix: string,\n      content: string,\n      onError?: (msg: string) => void\n    ): CborItem {\n      if (prefix === PREFIX_DT_TAGGED) return makeTagged(content);\n      return parseDtAppString(content, onError);\n    },\n\n    parseAppSequence(\n      prefix: string,\n      items: CborItem[],\n      onError?: (msg: string) => void\n    ): CborItem {\n      const str = stringFromAppSequence(items);\n      if (prefix === PREFIX_DT_TAGGED) return makeTagged(str);\n      return parseDtAppString(str, onError);\n    },\n\n    parseTag(tag: bigint, value: CborItem): CborItem | undefined {\n      if (tag !== TAG_EPOCH) return undefined;\n      let content:\n        CborEpochDtExtUint | CborEpochDtExtNint | CborEpochDtExtFloat;\n      if (value instanceof CborUint) {\n        content = new CborEpochDtExtUint(value.value, {\n          encodingWidth: value.encodingWidth,\n          ednSource: value.ednSource,\n        });\n      } else if (value instanceof CborNint) {\n        content = new CborEpochDtExtNint(value.value, {\n          encodingWidth: value.encodingWidth,\n          ednSource: value.ednSource,\n        });\n      } else if (value instanceof CborFloat) {\n        // Always preserve as float to avoid losing the original CBOR encoding\n        // type (e.g. float64(1.0) must not silently become uint(1)).\n        content = new CborEpochDtExtFloat(value.value, {\n          precision: value.precision,\n          literalSource: value.literalSource,\n        });\n      } else {\n        return undefined;\n      }\n      content.start = value.start;\n      content.end = value.end;\n      const result = useDate\n        ? new CborTaggedEpochDtAsDateExt(content)\n        : new CborTaggedEpochDtExt(content);\n      return result;\n    },\n  };\n\n  if (useDate) {\n    ext.fromJS = (\n      value: unknown,\n      _options: FromJSOptions\n    ): CborItem | undefined => {\n      if (value instanceof Date)\n        return new CborTaggedEpochDtAsDateExt(\n          epochToRfc3339(value.getTime() / 1000)\n        );\n      return undefined;\n    };\n    ext.isJSType = (value: unknown): value is Date => value instanceof Date;\n  }\n\n  return ext;\n}\n\n// ─── Extension objects ────────────────────────────────────────────────────────\n\n/**\n * Standard dt/DT CborExtension.\n * Tagged DT values produce CborTaggedEpochDtExt; toJS() returns a number.\n * For Date-based toJS() use dt_as_Date or createDtExtension({ jsDate: true }).\n */\nexport const dt: CborExtension = createDtExtension();\n\n/**\n * Full-featured dt/DT CborExtension with Date support.\n * Tagged DT values produce CborTaggedEpochDtAsDateExt; toJS() returns a Date.\n * fromJS(Date) converts Date instances to tagged epoch values.\n */\nexport const dt_as_Date: CborExtension = createDtExtension({ jsDate: true });\n\nexport default dt;\n","/**\n * Shared IPv4 / IPv6 address parsing and formatting utilities.\n * Used by the \"ip\"/\"IP\" extension (RFC 9164) and the \"cri\"/\"CRI\" extension\n * (draft-ietf-core-href).\n */\n\n// ─── Parsing ──────────────────────────────────────────────────────────────────\n\nexport function parseIPv4(str: string): Uint8Array {\n  const parts = str.split('.');\n  if (parts.length !== 4)\n    throw new SyntaxError(`ip: invalid IPv4 address: ${JSON.stringify(str)}`);\n  const bytes = new Uint8Array(4);\n  for (let i = 0; i < 4; i++) {\n    const s = parts[i];\n    if (!/^\\d+$/.test(s) || (s.length > 1 && s[0] === '0'))\n      throw new SyntaxError(`ip: invalid IPv4 octet: ${JSON.stringify(s)}`);\n    const n = parseInt(s, 10);\n    if (n > 255) throw new SyntaxError(`ip: IPv4 octet out of range: ${n}`);\n    bytes[i] = n;\n  }\n  return bytes;\n}\n\nexport function parseIPv6(str: string): Uint8Array {\n  const bytes = new Uint8Array(16);\n  if (str === '::') return bytes;\n\n  // Handle IPv4-mapped suffix, e.g. ::ffff:192.0.2.1\n  let head = str;\n  let ipv4Tail: Uint8Array | null = null;\n  const ipv4Match = str.match(/^(.*):(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})$/);\n  if (ipv4Match) {\n    head = ipv4Match[1];\n    if (head.endsWith(':')) head += ':'; // restore :: split by the regex\n    ipv4Tail = parseIPv4(ipv4Match[2]);\n  }\n\n  const halves = head.split('::');\n  if (halves.length > 2)\n    throw new SyntaxError(`ip: invalid IPv6 address: ${JSON.stringify(str)}`);\n\n  const doubleColon = halves.length === 2;\n  const leftParts = halves[0] ? halves[0].split(':') : [];\n  const rightParts = doubleColon && halves[1] ? halves[1].split(':') : [];\n  const totalGroups = ipv4Tail ? 6 : 8;\n\n  if (!doubleColon && leftParts.length !== totalGroups)\n    throw new SyntaxError(`ip: invalid IPv6 address: ${JSON.stringify(str)}`);\n  if (doubleColon && leftParts.length + rightParts.length >= totalGroups)\n    throw new SyntaxError(`ip: invalid IPv6 address: ${JSON.stringify(str)}`);\n\n  const zeroCount = totalGroups - leftParts.length - rightParts.length;\n  const groups = [...leftParts, ...Array(zeroCount).fill('0'), ...rightParts];\n\n  let offset = 0;\n  for (const g of groups) {\n    if (!/^[0-9a-fA-F]{1,4}$/.test(g))\n      throw new SyntaxError(`ip: invalid IPv6 group: ${JSON.stringify(g)}`);\n    const n = parseInt(g, 16);\n    bytes[offset++] = (n >> 8) & 0xff;\n    bytes[offset++] = n & 0xff;\n  }\n  if (ipv4Tail) bytes.set(ipv4Tail, 12);\n  return bytes;\n}\n\n// ─── Formatting ───────────────────────────────────────────────────────────────\n\nexport function formatIPv4(bytes: Uint8Array): string {\n  return Array.from(bytes).join('.');\n}\n\nexport function formatIPv6(bytes: Uint8Array): string {\n  // RFC 5952 §5: IPv4-mapped (::ffff:a.b.c.d) — bytes 0-9 zero, 10-11 = 0xffff\n  const isIpv4Mapped =\n    bytes.slice(0, 10).every((b) => b === 0) &&\n    bytes[10] === 0xff &&\n    bytes[11] === 0xff;\n\n  const ipv4Suffix = isIpv4Mapped ? formatIPv4(bytes.slice(12)) : null;\n\n  const hexGroups = ipv4Suffix ? 6 : 8;\n  const groups: number[] = [];\n  for (let i = 0; i < hexGroups * 2; i += 2)\n    groups.push((bytes[i] << 8) | bytes[i + 1]);\n\n  // RFC 5952 §4.2.3: find longest run of consecutive zero groups (≥ 2) for ::\n  let bestStart = -1,\n    bestLen = 0;\n  let i = 0;\n  while (i < hexGroups) {\n    if (groups[i] === 0) {\n      let j = i + 1;\n      while (j < hexGroups && groups[j] === 0) j++;\n      if (j - i > bestLen) {\n        bestStart = i;\n        bestLen = j - i;\n      }\n      i = j;\n    } else {\n      i++;\n    }\n  }\n  if (bestLen < 2) bestStart = -1;\n\n  const fmt = (g: number) => g.toString(16);\n  let hexPart: string;\n  if (bestStart === -1) {\n    hexPart = groups.map(fmt).join(':');\n  } else {\n    const left = groups.slice(0, bestStart).map(fmt).join(':');\n    const right = groups\n      .slice(bestStart + bestLen)\n      .map(fmt)\n      .join(':');\n    hexPart = `${left}::${right}`;\n  }\n\n  return ipv4Suffix ? `${hexPart}:${ipv4Suffix}` : hexPart;\n}\n","/**\n * CDN \"ip\" / \"IP\" application-extension (§3.2 of draft-ietf-cbor-edn-literals-25).\n *\n * Parses IPv4 / IPv6 address strings (RFC 3986 §3.2.2) into byte strings,\n * and optionally wraps them in CBOR tags per RFC 9164:\n *   - tag 52  IPv4 address or prefix\n *   - tag 54  IPv6 address or prefix\n *\n * Syntax:\n *   ip'192.0.2.42'          → CborIpExt       bare 4-byte string\n *   ip'2001:db8::1'         → CborIpExt       bare 16-byte string\n *   ip'192.0.2.0/24'        → CborIpPrefixExt bare [24, h'c00002']\n *   ip'2001:db8::/32'       → CborIpPrefixExt bare [32, h'20010db8']\n *   IP'192.0.2.42'          → CborTaggedIpExt tag(52, h'...')\n *   IP'2001:db8::1'         → CborTaggedIpExt tag(54, h'...')\n *   IP'192.0.2.0/24'        → CborTaggedIpExt tag(52, [24, h'c00002'])\n *   IP'2001:db8::/32'       → CborTaggedIpExt tag(54, [32, h'20010db8'])\n *\n * Lowercase ip produces the unwrapped content; uppercase IP additionally\n * wraps it in the IANA address family tag (52 for IPv4, 54 for IPv6).\n */\n\nimport type { ToCDNOptions } from '../types';\nimport type { CborExtension } from './types';\nimport type { CborItem } from '../ast/CborItem';\nimport { CborByteString } from '../ast/CborByteString';\nimport { CborTag } from '../ast/CborTag';\nimport { CborArray } from '../ast/CborArray';\nimport { CborUint } from '../ast/CborUint';\nimport { CborTextString } from '../ast/CborTextString';\nimport { parseIPv4, parseIPv6, formatIPv4, formatIPv6 } from '../utils/ip';\nimport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n  decideTaggedAppSeqRendering,\n  adjustRawAppSeqSource,\n  adjustAppSeqIndicator,\n} from '../cdn/serialize-utils';\n\nconst PREFIX_IP = 'ip';\nconst PREFIX_IP_TAGGED = 'IP';\nconst TAG_IPV4 = 52n;\nconst TAG_IPV6 = 54n;\n\nconst utf8Strict = new TextDecoder('utf-8', { fatal: true });\n\nfunction stringFromAppSequence(items: CborItem[]): string {\n  if (items.length !== 1)\n    throw new SyntaxError('ip<<...>>: expected exactly one item');\n  const item = items[0];\n  if (item instanceof CborTextString) return item.value;\n  if (item instanceof CborByteString) return utf8Strict.decode(item.value);\n  throw new SyntaxError('ip<<...>>: expected a text string or byte string');\n}\n\n// ─── Address parsing ──────────────────────────────────────────────────────────\n\nfunction parseAddress(str: string): { bytes: Uint8Array; isV4: boolean } {\n  if (/^\\d/.test(str) && str.includes('.') && !str.includes(':'))\n    return { bytes: parseIPv4(str), isV4: true };\n  return { bytes: parseIPv6(str), isV4: false };\n}\n\n// ─── Address formatting ───────────────────────────────────────────────────────\n\nfunction formatAddress(bytes: Uint8Array): string {\n  if (bytes.length === 4) return formatIPv4(bytes);\n  if (bytes.length === 16) return formatIPv6(bytes);\n  throw new SyntaxError(`ip: unexpected byte length: ${bytes.length}`);\n}\n\n// ─── CIDR helpers ─────────────────────────────────────────────────────────────\n\nfunction truncateToPrefix(bytes: Uint8Array, prefixLen: number): Uint8Array {\n  // RFC 9164 §2.3: zero host bits, then strip trailing zero bytes.\n  const masked = new Uint8Array(bytes.length);\n  masked.set(bytes);\n  const fullBytes = Math.floor(prefixLen / 8);\n  const extraBits = prefixLen % 8;\n  if (extraBits > 0 && fullBytes < bytes.length)\n    masked[fullBytes] &= (0xff << (8 - extraBits)) & 0xff;\n  for (let i = fullBytes + (extraBits > 0 ? 1 : 0); i < bytes.length; i++)\n    masked[i] = 0;\n  let end = Math.ceil(prefixLen / 8);\n  while (end > 0 && masked[end - 1] === 0) end--;\n  return masked.slice(0, end);\n}\n\nfunction expandToFull(truncated: Uint8Array, fullLen: number): Uint8Array {\n  const full = new Uint8Array(fullLen);\n  full.set(truncated);\n  return full;\n}\n\n// ─── CborItem subclasses ─────────────────────────────────────────────────────\n\n/**\n * Bare IP address byte string whose toCDN() emits ip'…' notation.\n */\nexport class CborIpExt extends CborByteString {\n  override _toCDN(options: ToCDNOptions | undefined, _depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, _depth);\n    const eiSuffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(BigInt(this.value.length))\n    );\n    const decision = decideTaggedAppSeqRendering(\n      options,\n      this.appSeqSource,\n      undefined,\n      this.appSeqSourceFeatures\n    );\n    if (decision === 'adjusted')\n      return adjustAppSeqIndicator(\n        this.appSeqSource!,\n        eiSuffix,\n        options,\n        this.appSeqInnerEnd,\n        this.appSeqComments\n      );\n    return `${PREFIX_IP}'${formatAddress(this.value)}'${eiSuffix}`;\n  }\n}\n\n/**\n * Bare IP address prefix (CIDR) whose toCDN() emits ip'…/prefix' notation.\n * Encoded as [prefixLen, truncatedBytes] per RFC 9164 §2.3, without a tag.\n */\nexport class CborIpPrefixExt extends CborArray {\n  private readonly _isV4: boolean;\n\n  constructor(prefixLen: number, truncated: Uint8Array, isV4: boolean) {\n    super([new CborUint(BigInt(prefixLen)), new CborByteString(truncated)]);\n    this._isV4 = isV4;\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, depth);\n    const decision = decideTaggedAppSeqRendering(\n      options,\n      this.appSeqSource,\n      undefined,\n      this.appSeqSourceFeatures\n    );\n    // This form never emits an encoding indicator of its own (unlike the\n    // other ip/dt notations), so 'adjusted' only ever strips one.\n    if (decision === 'adjusted')\n      return adjustAppSeqIndicator(\n        this.appSeqSource!,\n        '',\n        options,\n        this.appSeqInnerEnd,\n        this.appSeqComments\n      );\n    const prefixLen = Number((this.items[0] as CborUint).value);\n    const truncated = (this.items[1] as CborByteString).value;\n    const full = expandToFull(truncated, this._isV4 ? 4 : 16);\n    return `${PREFIX_IP}'${formatAddress(full)}/${prefixLen}'`;\n  }\n}\n\n/**\n * CBOR tag(52/54, …) IP address whose toCDN() emits IP'…' notation.\n * Content may be a byte string (plain address) or an array [prefix, bytes]\n * (CIDR prefix per RFC 9164).\n */\nexport class CborTaggedIpExt extends CborTag {\n  constructor(tag: bigint, content: CborItem) {\n    super(tag, content);\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, depth);\n    const decision = decideTaggedAppSeqRendering(\n      options,\n      this.appSeqSource,\n      this.ednSource,\n      this.appSeqSourceFeatures,\n      this.appSeqEncodingEditsComplete\n    );\n    if (decision === 'verbatim') return this.appSeqSource!;\n    if (decision === 'source')\n      return adjustRawAppSeqSource(\n        this.appSeqSource!,\n        options,\n        this.appSeqComments,\n        this.appSeqEncodingEdits\n      );\n    // Unlike dt's content classes, ip's content (CborByteString / CborArray\n    // / CborUint) never self-switches on `appStrings`, so no need to force\n    // it false here — doing so would also force hex byte-string encoding\n    // (see CborByteString._toCDN), overriding `bstrEncoding`/`sqstr`.\n    if (decision === 'structural') return super._toCDN(options, depth);\n    if (decision === 'adjusted') {\n      const eiSuffix = resolveEiSuffix(options, this.encodingWidth, () =>\n        canonicalEncodingWidth(this.tag)\n      );\n      return adjustAppSeqIndicator(\n        this.appSeqSource!,\n        eiSuffix,\n        options,\n        this.appSeqInnerEnd,\n        this.appSeqComments\n      );\n    }\n    const fullLen = this.tag === TAG_IPV4 ? 4 : 16;\n    const c = this.content as CborItem;\n    if (c instanceof CborByteString) {\n      // IP'...'_N only encodes the tag's width. If the inner byte string uses a\n      // non-canonical length header, fall back to generic tag notation to preserve it.\n      if (c.encodingWidth !== undefined) return super._toCDN(options, depth);\n      const eiSuffix = resolveEiSuffix(options, this.encodingWidth, () =>\n        canonicalEncodingWidth(this.tag)\n      );\n      return `${PREFIX_IP_TAGGED}'${formatAddress(c.value)}'${eiSuffix}`;\n    }\n    if (\n      c instanceof CborArray &&\n      c.items.length === 2 &&\n      c.items[0] instanceof CborUint &&\n      c.items[1] instanceof CborByteString\n    ) {\n      // Fall back if the inner array or either of its items has non-canonical encoding.\n      if (\n        c.encodingWidth !== undefined ||\n        (c.items[0] as CborUint).encodingWidth !== undefined ||\n        (c.items[1] as CborByteString).encodingWidth !== undefined\n      )\n        return super._toCDN(options, depth);\n      const prefixLen = Number((c.items[0] as CborUint).value);\n      const full = expandToFull((c.items[1] as CborByteString).value, fullLen);\n      const eiSuffix = resolveEiSuffix(options, this.encodingWidth, () =>\n        canonicalEncodingWidth(this.tag)\n      );\n      return `${PREFIX_IP_TAGGED}'${formatAddress(full)}/${prefixLen}'${eiSuffix}`;\n    }\n    return super._toCDN(options, depth);\n  }\n}\n\n// ─── Factory ──────────────────────────────────────────────────────────────────\n\nfunction buildIpValue(prefix: string, content: string): CborItem {\n  const slashIdx = content.indexOf('/');\n\n  if (slashIdx === -1) {\n    const { bytes, isV4 } = parseAddress(content);\n    if (prefix === PREFIX_IP_TAGGED)\n      return new CborTaggedIpExt(\n        isV4 ? TAG_IPV4 : TAG_IPV6,\n        new CborByteString(bytes)\n      );\n    return new CborIpExt(bytes);\n  }\n\n  // CIDR notation — supported with both lowercase ip and uppercase IP.\n  // lowercase ip → bare [prefixLen, truncatedBytes] (no tag)\n  // uppercase IP → tag(52/54, [prefixLen, truncatedBytes])\n  const addrStr = content.slice(0, slashIdx);\n  const lenStr = content.slice(slashIdx + 1);\n  if (!/^\\d+$/.test(lenStr))\n    throw new SyntaxError(\n      `ip: invalid prefix length: ${JSON.stringify(lenStr)}`\n    );\n  const prefixLen = parseInt(lenStr, 10);\n\n  const { bytes, isV4 } = parseAddress(addrStr);\n  const maxLen = isV4 ? 32 : 128;\n  if (prefixLen > maxLen)\n    throw new SyntaxError(\n      `ip: prefix length ${prefixLen} exceeds maximum ${maxLen} for ${isV4 ? 'IPv4' : 'IPv6'}`\n    );\n\n  const truncated = truncateToPrefix(bytes, prefixLen);\n  if (prefix === PREFIX_IP_TAGGED) {\n    return new CborTaggedIpExt(\n      isV4 ? TAG_IPV4 : TAG_IPV6,\n      new CborArray([\n        new CborUint(BigInt(prefixLen)),\n        new CborByteString(truncated),\n      ])\n    );\n  }\n  return new CborIpPrefixExt(prefixLen, truncated, isV4);\n}\n\n// ─── Factory ──────────────────────────────────────────────────────────────────\n\n/**\n * Create an ip/IP CborExtension (RFC 9164 / §3.2 of draft-ietf-cbor-edn-literals-25).\n *\n * - `ip'addr'`          → CborIpExt (bare byte string, 4 or 16 bytes)\n * - `IP'addr'`          → CborTaggedIpExt  tag(52 or 54, bytes)\n * - `IP'addr/prefix'`   → CborTaggedIpExt  tag(52 or 54, [prefix_len, bytes])\n * - parseTag(52/54, …)  → CborTaggedIpExt  (reversible via fromCBOR)\n * - fromJS(tagged obj)  → CborTaggedIpExt  (reversible via fromJS)\n */\nexport const ip: CborExtension = {\n  appStringPrefixes: [PREFIX_IP, PREFIX_IP_TAGGED],\n  tagNumbers: [TAG_IPV4, TAG_IPV6],\n  // ip/IP results always have a dedicated subclass (CborIpExt /\n  // CborIpPrefixExt / CborTaggedIpExt) that regenerates its notation by\n  // default; 'optional' preserves the <<...>> spelling only when\n  // ToCDNOptions.preserveAppSequence is set, without changing the\n  // returned node's class/identity (see preservedAppSeqSpelling).\n  preserveAppSeqSource: 'optional',\n\n  parseAppString(prefix: string, content: string): CborItem {\n    return buildIpValue(prefix, content);\n  },\n\n  parseAppSequence(prefix: string, items: CborItem[]): CborItem {\n    return buildIpValue(prefix, stringFromAppSequence(items));\n  },\n\n  parseTag(tag: bigint, value: CborItem): CborItem | undefined {\n    if (tag !== TAG_IPV4 && tag !== TAG_IPV6) return undefined;\n    if (value instanceof CborByteString || value instanceof CborArray)\n      return new CborTaggedIpExt(tag, value);\n    return undefined;\n  },\n};\n\nexport default ip;\n","/**\n * Standard CDN \"cri\" / \"CRI\" application-extension (§3.4 and §5.2.5 of draft-ietf-cbor-edn-literals-25).\n *\n * Converts URI references (RFC 3986) to CRI (Constrained Resource Identifier,\n * draft-ietf-core-href) CBOR array format and back.\n *\n * Syntax:\n *   cri'https://example.com/path'   → bare CRI array (no CBOR tag)\n *   CRI'https://example.com/path'   → tag(99, CRI array)\n *\n * CRI array structures (trailing defaults removed):\n *   Absolute:       [scheme, authority, path, ?query, ?fragment]\n *   Network-path:   [false, authority, path, ?query, ?fragment]\n *   Absolute-path:  [true, path, ?query, ?fragment]\n *   Relative-path:  [uint(discard), path, ?query, ?fragment]\n *   Same-document:  [0, ?query, ?fragment]\n *\n * where:\n *   scheme    = scheme-id (nint, e.g. -4 for https) or scheme-name (text)\n *   authority = [?userinfo, host, ?port]  — host is text labels or IP bytes\n *   path      = [\"seg1\", \"seg2\", ...]\n *   query     = [\"k=v\", ...]\n *   fragment  = text\n *   discard   = uint — number of path segments to remove from base before appending\n *               (1 = same directory, 2 = one level up \"../\", N = (N-1) levels up)\n *\n * Tag number 99 is used for the tagged \"CRI\" variant (§3.4 of draft-ietf-cbor-edn-literals-25).\n */\n\nimport type { ToCDNOptions } from '../types';\nimport type { CborExtension } from './types';\nimport type { CborItem } from '../ast/CborItem';\nimport { CborArray } from '../ast/CborArray';\nimport { CborTag } from '../ast/CborTag';\nimport { CborNint } from '../ast/CborNint';\nimport { CborUint } from '../ast/CborUint';\nimport { CborTextString } from '../ast/CborTextString';\nimport { CborByteString } from '../ast/CborByteString';\nimport { CborSimple } from '../ast/CborSimple';\nimport { parseIPv4, parseIPv6, formatIPv4, formatIPv6 } from '../utils/ip';\nimport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n  decideTaggedAppSeqRendering,\n  adjustRawAppSeqSource,\n  adjustAppSeqIndicator,\n} from '../cdn/serialize-utils';\n\n// ─── Constants ────────────────────────────────────────────────────────────────\n\nconst PREFIX_CRI = 'cri';\nconst PREFIX_CRI_TAGGED = 'CRI';\n\n/**\n * CBOR tag number for the tagged CRI variant (§3.4 and §5.2.5 of draft-ietf-cbor-edn-literals-25).\n */\nexport const TAG_CRI = 99n;\n\n// ─── Scheme-ID table ──────────────────────────────────────────────────────────\n\n/**\n * Scheme-id values from the IANA URI Schemes Registry.\n * Formula: scheme-id = -(scheme-number + 1)\n * https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml\n */\nconst SCHEME_ID_BY_NAME = new Map<string, bigint>([\n  ['coap', -1n],\n  ['coaps', -2n],\n  ['http', -3n],\n  ['https', -4n],\n  ['urn', -5n],\n  ['did', -6n],\n  ['coap+tcp', -7n],\n  ['coaps+tcp', -8n],\n  ['coap+ws', -25n],\n  ['coaps+ws', -26n],\n]);\n\nconst SCHEME_NAME_BY_ID = new Map<bigint, string>(\n  [...SCHEME_ID_BY_NAME.entries()].map(([name, id]) => [id, name])\n);\n\n// ─── Percent-encoding helpers ─────────────────────────────────────────────────\n\nfunction pctDecode(s: string): string {\n  try {\n    return decodeURIComponent(s);\n  } catch {\n    return s;\n  }\n}\n\nconst textEncoder = new TextEncoder();\nconst utf8Strict = new TextDecoder('utf-8', { fatal: true });\n\nfunction pctEncodeChar(c: string): string {\n  return Array.from(\n    textEncoder.encode(c),\n    (b) => `%${b.toString(16).toUpperCase().padStart(2, '0')}`\n  ).join('');\n}\n\nfunction encodePct(s: string, isAllowed: (c: string) => boolean): string {\n  let out = '';\n  for (const c of s) {\n    out += isAllowed(c) ? c : pctEncodeChar(c);\n  }\n  return out;\n}\n\n// unreserved  = A-Za-z0-9 \"-\" \".\" \"_\" \"~\"\n// sub-delims  = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\" / \"*\" / \"+\" / \",\" / \";\" / \"=\"\nfunction isUnreserved(c: string): boolean {\n  return /[A-Za-z0-9\\-._~]/.test(c);\n}\nfunction isSubDelim(c: string): boolean {\n  return /[!$&'()*+,;=]/.test(c);\n}\n\n// path segment: unreserved | sub-delims | \":\" | \"@\"\nfunction isPathAllowed(c: string): boolean {\n  return isUnreserved(c) || isSubDelim(c) || c === ':' || c === '@';\n}\n\n// query item: path chars | \"/\" | \"?\" — but NOT \"&\" (used as item separator between items)\nfunction isQueryItemAllowed(c: string): boolean {\n  return (isPathAllowed(c) || c === '/' || c === '?') && c !== '&';\n}\n\n// fragment: same as query\nfunction isFragmentAllowed(c: string): boolean {\n  return isPathAllowed(c) || c === '/' || c === '?';\n}\n\n// userinfo: unreserved | sub-delims | \":\" (RFC 3986 §3.2.1: \":\" is allowed in userinfo)\nfunction isUserinfoAllowed(c: string): boolean {\n  return isUnreserved(c) || isSubDelim(c) || c === ':';\n}\n\n// registered name label: unreserved | sub-delims\nfunction isRegNameAllowed(c: string): boolean {\n  return isUnreserved(c) || isSubDelim(c);\n}\n\n// ─── Authority conversion ──────────────────────────────────────────────────────\n\n/**\n * Parse URI authority string → CRI authority array.\n *\n * CRI authority = [?userinfo, host, ?port]\n *   userinfo = (false, text)          — two inline elements\n *   host-name = *text                 — zero-or-more text labels, inline\n *   host-ip   = bytes (4 or 16 bytes) — single inline element\n *   port      = uint 0..65535         — trailing optional element\n */\nfunction parseAuthorityStr(authStr: string): CborArray {\n  const items: CborItem[] = [];\n  let str = authStr;\n\n  // Strip userinfo (everything up to the last '@')\n  const atIdx = str.indexOf('@');\n  if (atIdx >= 0) {\n    items.push(CborSimple.FALSE);\n    items.push(new CborTextString(pctDecode(str.slice(0, atIdx))));\n    str = str.slice(atIdx + 1);\n  }\n\n  // IPv6 bracket literal: [addr]:port\n  let hostStr: string;\n  let portStr: string | null = null;\n\n  if (str.startsWith('[')) {\n    const close = str.indexOf(']');\n    if (close < 0)\n      throw new SyntaxError('cri: unterminated IPv6 bracket in authority');\n    hostStr = str.slice(1, close);\n    const after = str.slice(close + 1);\n    if (after.startsWith(':')) portStr = after.slice(1);\n    else if (after.length > 0)\n      throw new SyntaxError(\n        `cri: unexpected characters after ']' in authority`\n      );\n    items.push(new CborByteString(parseIPv6(hostStr)));\n  } else {\n    // IPv4 address or registered name — find port via last ':'\n    const colonIdx = str.lastIndexOf(':');\n    if (colonIdx >= 0) {\n      hostStr = str.slice(0, colonIdx);\n      portStr = str.slice(colonIdx + 1);\n    } else {\n      hostStr = str;\n    }\n\n    if (hostStr === '') {\n      // Empty host (e.g. file:///path) — zero labels, nothing pushed\n    } else if (/^\\d{1,3}(\\.\\d{1,3}){3}$/.test(hostStr)) {\n      items.push(new CborByteString(parseIPv4(hostStr)));\n    } else {\n      // Registered name: split by '.' into lowercase labels\n      for (const label of hostStr.toLowerCase().split('.')) {\n        items.push(new CborTextString(label));\n      }\n    }\n  }\n\n  // Optional port\n  if (portStr !== null && portStr !== '') {\n    if (!/^\\d+$/.test(portStr))\n      throw new SyntaxError(`cri: invalid port: ${JSON.stringify(portStr)}`);\n    const port = parseInt(portStr, 10);\n    if (port > 65535) throw new SyntaxError(`cri: port ${port} out of range`);\n    items.push(new CborUint(BigInt(port)));\n  }\n\n  return new CborArray(items);\n}\n\n/**\n * Convert CRI authority array → URI authority string.\n */\nfunction criAuthorityToUri(auth: CborArray): string {\n  const items = auth.items;\n  let idx = 0;\n  let result = '';\n\n  // Userinfo: (false, text) as two consecutive elements\n  if (\n    idx < items.length &&\n    items[idx] instanceof CborSimple &&\n    (items[idx] as CborSimple).value === 20\n  ) {\n    idx++; // skip false sentinel\n    const user = items[idx++] as CborTextString;\n    result += encodePct(user.value, isUserinfoAllowed) + '@';\n  }\n\n  if (idx >= items.length) return result; // empty host\n\n  const hostFirst = items[idx];\n  if (hostFirst instanceof CborByteString) {\n    idx++;\n    const { length } = hostFirst.value;\n    if (length === 4) {\n      result += formatIPv4(hostFirst.value);\n    } else if (length === 16) {\n      result += '[' + formatIPv6(hostFirst.value) + ']';\n    } else {\n      throw new Error(`cri: unexpected host-ip byte length: ${length}`);\n    }\n    // Optional zone-id (text string immediately after the IP bytes)\n    if (idx < items.length && items[idx] instanceof CborTextString) {\n      result += `%25${encodePct((items[idx++] as CborTextString).value, isRegNameAllowed)}`;\n    }\n  } else {\n    // Registered name: consecutive text strings up to the optional uint port\n    const labels: string[] = [];\n    while (idx < items.length && items[idx] instanceof CborTextString) {\n      labels.push(\n        encodePct((items[idx++] as CborTextString).value, isRegNameAllowed)\n      );\n    }\n    result += labels.join('.');\n  }\n\n  // Optional port\n  if (idx < items.length && items[idx] instanceof CborUint) {\n    result += ':' + (items[idx] as CborUint).value.toString();\n  }\n\n  return result;\n}\n\n// ─── CRI array ↔ URI string ───────────────────────────────────────────────────\n\n/**\n * Parse `//authority/path` from a string starting with `//`.\n * Returns the CRI authority array and path segments.\n */\nfunction _parseHierarchicalPart(rest: string): {\n  authority: CborArray;\n  pathSegments: CborTextString[];\n} {\n  const afterSlashes = rest.slice(2);\n  const slashIdx = afterSlashes.indexOf('/');\n  let authStr: string;\n  let pathSegments: CborTextString[];\n  if (slashIdx >= 0) {\n    authStr = afterSlashes.slice(0, slashIdx);\n    const pathStr = afterSlashes.slice(slashIdx + 1);\n    pathSegments = pathStr\n      .split('/')\n      .map((s) => new CborTextString(pctDecode(s)));\n  } else {\n    authStr = afterSlashes;\n    pathSegments = [];\n  }\n  return { authority: parseAuthorityStr(authStr), pathSegments };\n}\n\n/**\n * Parse a URI or URI-reference string into CRI array items.\n *\n * Supports all RFC 3986 reference forms:\n *   Absolute URI:       https://example.com/path  → [scheme, authority, path, ...]\n *   Network-path ref:   //other.example.com/path  → [false, authority, path, ...]\n *   Absolute-path ref:  /abs/path                 → [true, path, ...]\n *   Relative-path ref:  foo, ../bar               → [uint(discard), path, ...]\n *   Same-document ref:  #frag, ?q=1, (empty)      → [0, ...]\n *\n * Produces a compact representation with trailing defaults removed.\n */\nfunction uriToCriItems(str: string): CborItem[] {\n  // ── 1. Fragment ────────────────────────────────────────────────────────────\n  let rest = str;\n  let fragment: string | null = null;\n  const hashIdx = rest.indexOf('#');\n  if (hashIdx >= 0) {\n    fragment = pctDecode(rest.slice(hashIdx + 1));\n    rest = rest.slice(0, hashIdx);\n  }\n\n  // ── 2. Query ───────────────────────────────────────────────────────────────\n  let queryItems: CborTextString[] | null = null;\n  const qIdx = rest.indexOf('?');\n  if (qIdx >= 0) {\n    const qs = rest.slice(qIdx + 1);\n    rest = rest.slice(0, qIdx);\n    // Per draft-ietf-core-href §5.1:\n    //   [] (empty array) = absent query (no \"?\")  — this is the trailing default\n    //   [\"\"] (one empty string) = present but empty query (\"?\")\n    //   [\"k=v\", ...] = query with parameters\n    queryItems = qs.split('&').map((s) => new CborTextString(pctDecode(s)));\n  }\n\n  // ── 3. Detect reference form and build leading items ───────────────────────\n  const items: CborItem[] = [];\n\n  const schemeMatch = /^([a-zA-Z][a-zA-Z0-9+.\\-]*):([\\s\\S]*)$/.exec(rest);\n  if (schemeMatch) {\n    // Absolute URI: scheme + hier-part\n    const schemeName = schemeMatch[1].toLowerCase();\n    const hierPart = schemeMatch[2];\n    const schemeId = SCHEME_ID_BY_NAME.get(schemeName);\n    items.push(\n      schemeId !== undefined\n        ? new CborNint(schemeId)\n        : new CborTextString(schemeName)\n    );\n    if (hierPart.startsWith('//')) {\n      const { authority, pathSegments } = _parseHierarchicalPart(hierPart);\n      items.push(authority, new CborArray(pathSegments));\n    } else if (hierPart.startsWith('/')) {\n      const pathSegments = hierPart\n        .slice(1)\n        .split('/')\n        .map((s) => new CborTextString(pctDecode(s)));\n      items.push(CborSimple.NULL, new CborArray(pathSegments));\n    } else {\n      const pathSegments = hierPart\n        .split('/')\n        .map((s) => new CborTextString(pctDecode(s)));\n      items.push(CborSimple.TRUE, new CborArray(pathSegments));\n    }\n  } else if (rest.startsWith('//')) {\n    // Network-path reference: //authority/path\n    const { authority, pathSegments } = _parseHierarchicalPart(rest);\n    items.push(CborSimple.FALSE, authority, new CborArray(pathSegments));\n  } else if (rest.startsWith('/')) {\n    // Absolute-path reference: /path\n    const pathSegments = rest\n      .slice(1)\n      .split('/')\n      .map((s) => new CborTextString(pctDecode(s)));\n    items.push(CborSimple.TRUE, new CborArray(pathSegments));\n  } else if (rest === '') {\n    // Same-document reference (only query/fragment differ from base)\n    items.push(new CborUint(0n));\n  } else {\n    // Relative-path reference: count leading ../ sequences\n    let discard = 1n;\n    let pathRest = rest;\n    let hasDotSlash = false;\n    if (pathRest.startsWith('./')) {\n      hasDotSlash = true;\n      pathRest = pathRest.slice(2);\n    }\n    while (pathRest.startsWith('../')) {\n      discard++;\n      pathRest = pathRest.slice(3);\n    }\n    // Handle lone '..' or '.' at end\n    if (pathRest === '..') {\n      discard++;\n      pathRest = '';\n    } else if (pathRest === '.') {\n      pathRest = '';\n    }\n    // RFC 3986 §3.3 path-noscheme: the first segment of a relative-path reference\n    // must not contain ':' unless the path was explicitly prefixed with \"./\"\n    // (which disambiguates it from a scheme). Without \"./\" the colon makes the\n    // reference look like an absolute URI to parsers, and is most likely a typo.\n    // This check applies only when discard=1 (same-directory) and no \"./\" was given.\n    // For discard≥2 (e.g. \"../foo:bar\") the leading \"../\" already disambiguates.\n    if (discard === 1n && !hasDotSlash && pathRest !== '') {\n      const firstSeg = pathRest.split('/')[0];\n      if (firstSeg.includes(':'))\n        throw new SyntaxError(\n          `cri: invalid relative-path reference — first segment must not contain ':' without a './' prefix (RFC 3986 §3.3): ${JSON.stringify(str)}`\n        );\n    }\n    const pathSegments =\n      pathRest === ''\n        ? []\n        : pathRest.split('/').map((s) => new CborTextString(pctDecode(s)));\n    items.push(new CborUint(discard), new CborArray(pathSegments));\n  }\n\n  // ── 4. Append query and fragment ──────────────────────────────────────────\n  if (queryItems !== null) items.push(new CborArray(queryItems));\n  if (fragment !== null) {\n    // When fragment is present but query is absent, use null as placeholder so that\n    // \"no query\" is distinguishable from \"empty query []\" at the query position.\n    if (queryItems === null) items.push(CborSimple.NULL);\n    items.push(new CborTextString(fragment));\n  }\n\n  // ── 5. Trim trailing defaults ─────────────────────────────────────────────\n  // Remove null placeholder for absent query (always at items.length - 2 when present)\n  if (fragment !== null && queryItems === null) {\n    items.splice(items.length - 2, 1);\n  }\n  // Remove trailing empty PATH array — but only when it is truly the last element\n  // (i.e., neither a query nor a fragment follows it). An empty QUERY array []\n  // means \"query is present but empty\" (?), which must be preserved.\n  if (queryItems === null && fragment === null) {\n    const last = items[items.length - 1];\n    if (last instanceof CborArray && last.items.length === 0) {\n      items.pop();\n    }\n  }\n\n  // ── 6. Canonical same-document form ──────────────────────────────────────\n  // Per §5.2: [discard=0] with no other items is sent as [] (empty array).\n  if (\n    items.length === 1 &&\n    items[0] instanceof CborUint &&\n    (items[0] as CborUint).value === 0n\n  ) {\n    return [];\n  }\n\n  return items;\n}\n\n/**\n * Encode query and fragment items from `items[startIdx..]` into a URI suffix string.\n * Handles both the `[] = empty query`, `[items] = query params`, `null = absent query`,\n * and optional trailing text fragment.\n */\nfunction _criSuffix(items: readonly CborItem[], startIdx: number): string {\n  let idx = startIdx;\n  let result = '';\n\n  if (idx < items.length) {\n    const qi = items[idx];\n    if (qi instanceof CborArray) {\n      idx++;\n      // Per §5.1 / draft-ietf-core-href:\n      //   [] (empty array) = absent query — omit \"?\" entirely (trailing default)\n      //   [\"\"] = present but empty query — emit \"?\"\n      //   [\"k=v\", ...] = query with parameters — emit \"?k=v&...\"\n      if (qi.items.length > 0) {\n        const params = qi.items.map((s) => {\n          if (!(s instanceof CborTextString))\n            throw new Error('cri: query item must be a text string');\n          return encodePct(s.value, isQueryItemAllowed);\n        });\n        result += '?' + params.join('&');\n      }\n      // [] = absent query → no '?' emitted\n    } else if (qi instanceof CborSimple && qi.value === 22) {\n      idx++; // explicit null = absent query component\n    }\n    // else: not a query item (text fragment follows); leave idx unchanged\n  }\n\n  if (idx < items.length && items[idx] instanceof CborTextString) {\n    result +=\n      '#' + encodePct((items[idx] as CborTextString).value, isFragmentAllowed);\n  }\n\n  return result;\n}\n\n/**\n * Encode a CRI path array into URI path segments.\n */\nfunction _criPathSegs(pathArr: CborArray): string[] {\n  return pathArr.items.map((s) => {\n    if (!(s instanceof CborTextString))\n      throw new Error('cri: path segment must be a text string');\n    return encodePct(s.value, isPathAllowed);\n  });\n}\n\n/**\n * Convert CRI array items → URI string.\n *\n * Handles all CRI reference forms:\n *   Absolute:       first element is CborNint or CborTextString (scheme)\n *   Network-path:   first element is false (CborSimple(20))\n *   Absolute-path:  first element is true (CborSimple(21))\n *   Relative-path:  first element is CborUint (discard count ≥ 1)\n *   Same-document:  first element is CborUint(0)\n */\nfunction criItemsToUri(items: readonly CborItem[]): string {\n  // Per §5.2: [] (empty array) is the canonical form of the same-document\n  // reference [discard=0] with no query or fragment.\n  if (items.length === 0) return '';\n\n  let idx = 0;\n  const first = items[idx++];\n\n  // ── Absolute URI ──────────────────────────────────────────────────────────\n  if (first instanceof CborNint || first instanceof CborTextString) {\n    let schemePart: string;\n    if (first instanceof CborNint) {\n      const name = SCHEME_NAME_BY_ID.get(first.value);\n      if (name === undefined)\n        throw new Error(`cri: unrecognised scheme-id ${first.value}`);\n      schemePart = name + ':';\n    } else {\n      schemePart = (first as CborTextString).value + ':';\n    }\n\n    if (idx >= items.length) return schemePart;\n\n    const second = items[idx++];\n    let authorityPart = '';\n    let rootedPath = false;\n\n    if (second instanceof CborArray) {\n      authorityPart = '//' + criAuthorityToUri(second);\n      rootedPath = true;\n    } else if (second instanceof CborSimple) {\n      if (second.value === 22)\n        rootedPath = true; // null = NOAUTH-ROOTBASED\n      else if (second.value === 21)\n        rootedPath = false; // true = NOAUTH-ROOTLESS\n      else\n        throw new Error(\n          `cri: unexpected no-authority value: simple(${second.value})`\n        );\n    } else {\n      throw new Error('cri: unexpected type for authority element');\n    }\n\n    let pathPart = '';\n    if (idx < items.length && items[idx] instanceof CborArray) {\n      const pathArr = items[idx++] as CborArray;\n      if (pathArr.items.length > 0) {\n        pathPart = (rootedPath ? '/' : '') + _criPathSegs(pathArr).join('/');\n      }\n    }\n\n    return schemePart + authorityPart + pathPart + _criSuffix(items, idx);\n  }\n\n  // ── Network-path reference: [false, authority-array, path-array, ...] ─────\n  if (first instanceof CborSimple && first.value === 20) {\n    if (idx >= items.length || !(items[idx] instanceof CborArray))\n      throw new Error(\n        'cri: network-path reference requires an authority array'\n      );\n    const authority = criAuthorityToUri(items[idx++] as CborArray);\n    let pathPart = '';\n    if (idx < items.length && items[idx] instanceof CborArray) {\n      const pathArr = items[idx++] as CborArray;\n      if (pathArr.items.length > 0) {\n        pathPart = '/' + _criPathSegs(pathArr).join('/');\n      }\n    }\n    return '//' + authority + pathPart + _criSuffix(items, idx);\n  }\n\n  // ── Absolute-path reference: [true, path-array, ...] ─────────────────────\n  if (first instanceof CborSimple && first.value === 21) {\n    let pathPart = '/';\n    if (idx < items.length && items[idx] instanceof CborArray) {\n      const pathArr = items[idx++] as CborArray;\n      pathPart = '/' + _criPathSegs(pathArr).join('/');\n    }\n    return pathPart + _criSuffix(items, idx);\n  }\n\n  // ── Relative-path / same-document: [uint(discard), ...] ──────────────────\n  if (first instanceof CborUint) {\n    const discard = first.value;\n\n    if (discard === 0n) {\n      // Same-document reference: path unchanged, only query/fragment differ\n      return _criSuffix(items, idx);\n    }\n\n    // discard=1 → same directory (no \"../\" prefix)\n    // discard=N → (N-1) \"../\" prefixes\n    const dotdots = discard === 1n ? '' : '../'.repeat(Number(discard) - 1);\n\n    let pathPart: string;\n    if (idx < items.length && items[idx] instanceof CborArray) {\n      const pathArr = items[idx++] as CborArray;\n      if (pathArr.items.length > 0) {\n        const segs = _criPathSegs(pathArr);\n        // §6.1: when discard=1, prefix with \"./\" if the first segment contains \":\"\n        // to prevent URI parsers from misreading it as a scheme (RFC 3986 §3.3).\n        const needsDotSlash = discard === 1n && segs[0].includes(':');\n        pathPart = (needsDotSlash ? './' : dotdots) + segs.join('/');\n      } else {\n        // Empty path array (should be trimmed, but handle defensively)\n        pathPart = dotdots === '' ? './' : dotdots;\n      }\n    } else {\n      // No path array (trimmed away)\n      pathPart = dotdots === '' ? './' : dotdots;\n    }\n\n    return pathPart + _criSuffix(items, idx);\n  }\n\n  throw new Error(`cri: unrecognised first element type in CRI array`);\n}\n\n// ─── CborItem subclasses ──────────────────────────────────────────────────────\n\n/**\n * Bare CRI array whose toCDN() emits cri'…' notation.\n * Falls back to generic array notation if the content cannot be expressed as a URI.\n */\nexport class CborCriExt extends CborArray {\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, depth);\n    const eiSuffix = resolveEiSuffix(options, this.encodingWidth, () =>\n      canonicalEncodingWidth(BigInt(this.items.length))\n    );\n    const decision = decideTaggedAppSeqRendering(\n      options,\n      this.appSeqSource,\n      undefined,\n      this.appSeqSourceFeatures\n    );\n    if (decision === 'adjusted')\n      return adjustAppSeqIndicator(\n        this.appSeqSource!,\n        eiSuffix,\n        options,\n        this.appSeqInnerEnd,\n        this.appSeqComments\n      );\n    try {\n      return `${PREFIX_CRI}'${criItemsToUri(this.items)}'${eiSuffix}`;\n    } catch {\n      return super._toCDN(options, depth);\n    }\n  }\n}\n\n/**\n * tag(99, CRI array) whose toCDN() emits CRI'…' notation.\n * Falls back to generic tag notation if the content cannot be expressed as a URI.\n */\nexport class CborTaggedCriExt extends CborTag {\n  constructor(content: CborArray) {\n    super(TAG_CRI, content);\n  }\n\n  override _toCDN(options: ToCDNOptions | undefined, depth: number): string {\n    if (options?.appStrings === false) return super._toCDN(options, depth);\n    const decision = decideTaggedAppSeqRendering(\n      options,\n      this.appSeqSource,\n      this.ednSource,\n      this.appSeqSourceFeatures,\n      this.appSeqEncodingEditsComplete\n    );\n    if (decision === 'verbatim') return this.appSeqSource!;\n    if (decision === 'source')\n      return adjustRawAppSeqSource(\n        this.appSeqSource!,\n        options,\n        this.appSeqComments,\n        this.appSeqEncodingEdits\n      );\n    // Like dt's content classes, cri's content (CborCriExt) re-switches to\n    // its own app-string notation unless `appStrings` is forced false here.\n    if (decision === 'structural')\n      return super._toCDN({ ...options, appStrings: false }, depth);\n    try {\n      const inner = this.content as CborArray;\n      // CRI'...'_N only encodes the tag's width. If the inner array uses a\n      // non-canonical count header, fall back to generic tag notation to preserve it.\n      if (inner.encodingWidth !== undefined)\n        return super._toCDN(options, depth);\n      const eiSuffix = resolveEiSuffix(options, this.encodingWidth, () =>\n        canonicalEncodingWidth(TAG_CRI)\n      );\n      if (decision === 'adjusted')\n        return adjustAppSeqIndicator(\n          this.appSeqSource!,\n          eiSuffix,\n          options,\n          this.appSeqInnerEnd,\n          this.appSeqComments\n        );\n      return `${PREFIX_CRI_TAGGED}'${criItemsToUri(inner.items)}'${eiSuffix}`;\n    } catch {\n      return super._toCDN(options, depth);\n    }\n  }\n}\n\n// ─── Builder ──────────────────────────────────────────────────────────────────\n\nfunction stringFromAppSequence(items: CborItem[]): string {\n  if (items.length !== 1)\n    throw new SyntaxError('cri<<...>>: expected exactly one item');\n  const item = items[0];\n  if (item instanceof CborTextString) return item.value;\n  if (item instanceof CborByteString) return utf8Strict.decode(item.value);\n  throw new SyntaxError('cri<<...>>: expected a text string or byte string');\n}\n\nfunction buildCriValue(prefix: string, uri: string): CborItem {\n  const criItems = uriToCriItems(uri);\n  const arr = new CborCriExt(criItems);\n  if (prefix === PREFIX_CRI_TAGGED) return new CborTaggedCriExt(arr);\n  return arr;\n}\n\n// ─── Extension factory ────────────────────────────────────────────────────────\n\n/**\n * Create the cri/CRI CborExtension (§3.4 and §5.2.5 of draft-ietf-cbor-edn-literals-25).\n *\n * - `cri'uri'`        → CborCriExt (bare CRI array, no CBOR tag)\n * - `CRI'uri'`        → CborTaggedCriExt tag(99, CRI array)\n * - parseTag(99n, …)  → CborTaggedCriExt (roundtrip from CBOR binary)\n */\nexport const cri: CborExtension = {\n  appStringPrefixes: [PREFIX_CRI, PREFIX_CRI_TAGGED],\n  tagNumbers: [TAG_CRI],\n  // cri/CRI results always have a dedicated subclass (CborCriExt /\n  // CborTaggedCriExt) that regenerates its notation by default; 'optional'\n  // preserves the source spelling only when ToCDNOptions.preserveAppSequence\n  // is set, without changing the returned node's class/identity.\n  preserveAppSeqSource: 'optional',\n\n  parseAppString(prefix: string, content: string): CborItem {\n    return buildCriValue(prefix, content);\n  },\n\n  parseAppSequence(prefix: string, items: CborItem[]): CborItem {\n    return buildCriValue(prefix, stringFromAppSequence(items));\n  },\n\n  parseTag(tag: bigint, value: CborItem): CborItem | undefined {\n    if (tag !== TAG_CRI) return undefined;\n    if (!(value instanceof CborArray)) return undefined;\n    const inner = new CborCriExt(value.items, {\n      indefiniteLength: value.indefiniteLength,\n      encodingWidth: value.encodingWidth,\n    });\n    inner.start = value.start;\n    inner.end = value.end;\n    return new CborTaggedCriExt(inner);\n  },\n};\n\nexport default cri;\n","/**\n * Built-in bignum extension (RFC 8949 §3.4.3).\n *\n * Intercepts tag 2 (unsigned bignum) and tag 3 (negative bignum) during\n * fromCBOR() and fromCDN() so that out-of-range values are decoded as\n * CborBigUint / CborBigNint rather than plain CborTag nodes.\n *\n * In-range values (those that fit in uint64 / nint64) are left as plain\n * CborTag so that non-canonical bignum encodings of small integers don't\n * silently change behaviour.\n */\n\nimport type { CborExtension } from './types';\nimport type { CborItem } from '../ast/CborItem';\nimport { CborByteString } from '../ast/CborByteString';\nimport {\n  CborBigUint,\n  CborBigNint,\n  bytesToBigint,\n  BIGNUM_UINT_TAG,\n  BIGNUM_NINT_TAG,\n} from '../ast/CborBignum';\n\nconst UINT64_MAX = 0xffff_ffff_ffff_ffffn;\nconst NINT64_MIN = -(UINT64_MAX + 1n);\n\nexport const bignum: CborExtension = {\n  tagNumbers: [BIGNUM_UINT_TAG, BIGNUM_NINT_TAG],\n\n  parseTag(tag: bigint, value: CborItem): CborItem | undefined {\n    if (!(value instanceof CborByteString)) return undefined;\n\n    if (tag === BIGNUM_UINT_TAG) {\n      const n = bytesToBigint(value.value);\n      if (n > UINT64_MAX) return new CborBigUint(n);\n      return undefined; // fits in uint64 — leave as plain CborTag\n    }\n\n    if (tag === BIGNUM_NINT_TAG) {\n      const n = -1n - bytesToBigint(value.value);\n      if (n < NINT64_MIN) return new CborBigNint(n);\n      return undefined; // fits in nint64 — leave as plain CborTag\n    }\n\n    return undefined;\n  },\n};\n\nexport default bignum;\n","import type { FromCBOROptions, DecodeWarning, CborExtension } from '../types';\nimport type { CborItem } from '../ast/CborItem';\nimport { resolveBuiltinExtensions } from '../extensions/builtins';\nimport { CborUint } from '../ast/CborUint';\nimport { CborNint } from '../ast/CborNint';\nimport { CborByteString } from '../ast/CborByteString';\nimport { CborIndefiniteByteString } from '../ast/CborIndefiniteByteString';\nimport { CborTextString } from '../ast/CborTextString';\nimport { CborIndefiniteTextString } from '../ast/CborIndefiniteTextString';\nimport { CborArray } from '../ast/CborArray';\nimport { CborMap } from '../ast/CborMap';\nimport { CborTag } from '../ast/CborTag';\nimport { CborFloat } from '../ast/CborFloat';\nimport { CborSimple } from '../ast/CborSimple';\nimport { float16BitsToFloat64 } from '../utils/float16';\nimport { bytesToHex } from '../utils/hex';\nimport {\n  MT_UINT,\n  MT_NINT,\n  MT_BYTES,\n  MT_TEXT,\n  MT_ARRAY,\n  MT_MAP,\n  MT_TAG,\n  MT_SIMPLE,\n  AI_1BYTE,\n  AI_2BYTE,\n  AI_4BYTE,\n  AI_8BYTE,\n  AI_INDEFINITE,\n  BREAK_CODE,\n} from './constants';\nimport type { EncodingWidth } from './encode';\n\n// ─── Helpers ──────────────────────────────────────────────────────────────────\n\n/**\n * Returns a non-canonical EncodingWidth when the CBOR additional-info byte\n * uses more bytes than the minimum needed for `value`. Returns undefined for\n * canonical (minimum-width) encodings so they round-trip without an _N marker.\n *\n * Canonical ranges: immediate 0–23, 1-byte 24–255, 2-byte 256–65535,\n * 4-byte 65536–4294967295, 8-byte ≥ 4294967296.\n */\nfunction aiToNonCanonicalEW(\n  ai: number,\n  value: bigint\n): EncodingWidth | undefined {\n  if (ai === AI_1BYTE && value <= 23n) return 0;\n  if (ai === AI_2BYTE && value <= 0xffn) return 1;\n  if (ai === AI_4BYTE && value <= 0xffffn) return 2;\n  if (ai === AI_8BYTE && value <= 0xffff_ffffn) return 3;\n  return undefined;\n}\n\n/**\n * Number twin of {@link aiToNonCanonicalEW}, for the length/count arguments\n * read by {@link readLength}.  Values ≥ 2^53 arrive rounded, but they are far\n * above every threshold here, so the result is unaffected.\n */\nfunction aiToNonCanonicalEWLen(\n  ai: number,\n  value: number\n): EncodingWidth | undefined {\n  if (ai === AI_1BYTE && value <= 23) return 0;\n  if (ai === AI_2BYTE && value <= 0xff) return 1;\n  if (ai === AI_4BYTE && value <= 0xffff) return 2;\n  if (ai === AI_8BYTE && value <= 0xffff_ffff) return 3;\n  return undefined;\n}\n\nconst textDecoderStrict = new TextDecoder('utf-8', {\n  fatal: true,\n  ignoreBOM: true,\n});\n\nconst textDecoderLenient = new TextDecoder('utf-8', {\n  fatal: false,\n  ignoreBOM: true,\n});\n\nfunction decodeError(msg: string): never {\n  throw new Error(`CBOR decode error: ${msg}`);\n}\n\n/**\n * Emit a CBOR validity violation warning and, unless `strict: false`, throw.\n * Returns the created `DecodeWarning` (only reachable in non-strict mode).\n * For truly malformed data that cannot be recovered, use `decodeError` instead.\n */\nfunction strictViolation(\n  msg: string,\n  offset: number,\n  options: FromCBOROptions | undefined\n): DecodeWarning {\n  const warning: DecodeWarning = { message: msg, offset };\n  if (options?.onWarning) {\n    options.onWarning(warning);\n  } else if (!options?.silent) {\n    console.warn(`CBOR strict violation at offset ${offset}: ${msg}`);\n  }\n  if (options?.strict !== false) {\n    throw new Error(`CBOR decode error: ${msg}`);\n  }\n  return warning;\n}\n\nfunction addWarning(node: CborItem, warning: DecodeWarning): void {\n  node.warnings ??= [];\n  node.warnings.push(warning);\n}\n\n/**\n * Return a data-model fingerprint for a CBOR map key.\n *\n * The fingerprint is designed so that two keys are equal if and only if they\n * represent the same CBOR data-model value, regardless of the encoding form:\n *   - Integers: compared by numeric value (width differences ignored)\n *   - Text strings: compared by Unicode string content (definite vs indefinite ignored)\n *   - Byte strings: compared by raw byte sequence (definite vs indefinite ignored)\n *   - Floats: compared by numeric value (precision ignored; all NaN treated equal)\n *   - Simple values: compared by simple value number\n *   - Arrays/maps/tags: recursively fingerprinted\n *\n * Implemented as two functions: `fingerprintKeyVal` builds a nested-array\n * structure (no pre-serialised strings), and `fingerprintKey` serialises it\n * with a single JSON.stringify call.  Keeping recursion in the array domain\n * avoids the exponential character-escaping blowup that occurs when\n * pre-serialised JSON strings are embedded inside further JSON.stringify calls.\n */\nfunction fingerprintKeyVal(key: CborItem): unknown {\n  if (key instanceof CborUint) return ['u', String(key.value)];\n  if (key instanceof CborNint) return ['n', String(key.value)];\n  if (key instanceof CborTextString) return ['t', key.value];\n  if (key instanceof CborIndefiniteTextString)\n    return ['t', key.chunks.map((c) => c.value).join('')];\n  if (key instanceof CborByteString) return ['b', bytesToHex(key.value)];\n  if (key instanceof CborIndefiniteByteString) {\n    let h = '';\n    for (const chunk of key.chunks) h += bytesToHex(chunk.value);\n    return ['b', h];\n  }\n  if (key instanceof CborFloat) {\n    // Use String() for all float cases: avoids JSON.stringify silently converting\n    // NaN and ±Infinity to null, and -0 to \"0\".\n    if (isNaN(key.value)) return ['f', 'NaN'];\n    if (Object.is(key.value, -0)) return ['f', '-0'];\n    return ['f', String(key.value)];\n  }\n  if (key instanceof CborSimple) return ['s', key.value];\n  if (key instanceof CborArray) return ['A', key.items.map(fingerprintKeyVal)];\n  if (key instanceof CborMap) {\n    const pairs = key.entries.map(([k, v]) => [\n      fingerprintKeyVal(k),\n      fingerprintKeyVal(v),\n    ]);\n    // 0/1 entries: nothing to sort — and skipping the stringify here keeps\n    // deeply-nested single-entry map chains linear instead of quadratic.\n    if (pairs.length <= 1) return ['M', pairs];\n    // Sort by key fingerprint so that maps with the same entries in different\n    // insertion order fingerprint identically (RFC 8949 data model: unordered).\n    // Decorate-sort-undecorate: stringify each key once, not per comparison.\n    const decorated = pairs.map(\n      (pair) => [JSON.stringify(pair[0]), pair] as const\n    );\n    decorated.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));\n    return ['M', decorated.map((d) => d[1])];\n  }\n  if (key instanceof CborTag)\n    return ['G', String(key.tag), fingerprintKeyVal(key.content)];\n  // Fallback for any remaining AST node (e.g. CborEmbeddedCBOR): canonical CBOR bytes.\n  return ['c', bytesToHex(key.toCBOR())];\n}\n\nfunction fingerprintKey(key: CborItem): string {\n  // Fast paths for scalar keys (the overwhelmingly common case) — avoids a\n  // throwaway array + JSON.stringify per key.  JSON fingerprints always start\n  // with '[', so these single-letter prefixes cannot collide with them, and\n  // each fast-path prefix is distinct so they cannot collide with each other.\n  if (key instanceof CborUint) return 'u' + key.value;\n  if (key instanceof CborNint) return 'n' + key.value;\n  if (key instanceof CborTextString) return 't' + key.value;\n  if (key instanceof CborIndefiniteTextString) {\n    let s = 't';\n    for (const c of key.chunks) s += c.value;\n    return s;\n  }\n  if (key instanceof CborByteString) return 'b' + bytesToHex(key.value);\n  if (key instanceof CborIndefiniteByteString) {\n    let s = 'b';\n    for (const chunk of key.chunks) s += bytesToHex(chunk.value);\n    return s;\n  }\n  if (key instanceof CborFloat) {\n    if (isNaN(key.value)) return 'fNaN';\n    if (Object.is(key.value, -0)) return 'f-0';\n    return 'f' + key.value;\n  }\n  if (key instanceof CborSimple) return 's' + key.value;\n  return JSON.stringify(fingerprintKeyVal(key));\n}\n\n/**\n * Pre-computed BigInt values for CBOR inline arguments 0–23.\n * readArgument() is called for every data item header; avoiding BigInt()\n * construction for the common small-integer case saves measurable time.\n */\nconst SMALL_BIGINTS: readonly bigint[] = Array.from({ length: 24 }, (_, i) =>\n  BigInt(i)\n);\n\n/**\n * Default resolved builtins (no `builtinExtensions` override) filtered to\n * those with a parseTag hook, cached after first use. Lazy (not module-level)\n * because cbordata.ts imports decoder.ts, forming a cycle that leaves the\n * builtins module's exports undefined at module init time.\n */\nlet _defaultTagExts: readonly CborExtension[] | undefined;\nfunction getBuiltinTagExts(\n  builtinExtensions: CborExtension[] | false | undefined\n): readonly CborExtension[] {\n  if (builtinExtensions === undefined)\n    return (_defaultTagExts ??= resolveBuiltinExtensions(undefined).filter(\n      (ext) => ext.parseTag !== undefined\n    ));\n  return resolveBuiltinExtensions(builtinExtensions).filter(\n    (ext) => ext.parseTag !== undefined\n  );\n}\n\n/**\n * Decode a short (< 64 byte) pure-ASCII UTF-8 sequence without invoking\n * TextDecoder. Returns undefined if any byte is >= 0x80 (non-ASCII).\n * Only called for length < 64; longer strings use TextDecoder directly to\n * avoid the double-scan cost of failing mid-way through a large buffer.\n */\nfunction tryDecodeAscii(bytes: Uint8Array, length: number): string | undefined {\n  for (let i = 0; i < length; i++) {\n    if (bytes[i] >= 0x80) return undefined;\n  }\n  // eslint-disable-next-line prefer-spread\n  return String.fromCharCode.apply(null, bytes as unknown as number[]);\n}\n\n/**\n * Read the CBOR \"argument\" that follows the initial byte.\n * For ai 0–23 the argument is inline; for 24–27 it occupies 1/2/4/8 bytes.\n */\nfunction readArgument(\n  view: DataView,\n  offset: number,\n  ai: number\n): { value: bigint; nextOffset: number } {\n  if (ai <= 23) {\n    return { value: SMALL_BIGINTS[ai], nextOffset: offset };\n  }\n  switch (ai) {\n    case AI_1BYTE:\n      if (offset + 1 > view.byteLength) decodeError('unexpected end of input');\n      return { value: BigInt(view.getUint8(offset)), nextOffset: offset + 1 };\n    case AI_2BYTE:\n      if (offset + 2 > view.byteLength) decodeError('unexpected end of input');\n      return {\n        value: BigInt(view.getUint16(offset, false)),\n        nextOffset: offset + 2,\n      };\n    case AI_4BYTE:\n      if (offset + 4 > view.byteLength) decodeError('unexpected end of input');\n      return {\n        value: BigInt(view.getUint32(offset, false)),\n        nextOffset: offset + 4,\n      };\n    case AI_8BYTE:\n      if (offset + 8 > view.byteLength) decodeError('unexpected end of input');\n      return {\n        value: view.getBigUint64(offset, false),\n        nextOffset: offset + 8,\n      };\n    default:\n      decodeError(`reserved additional info value: ${ai}`);\n  }\n}\n\n/**\n * Read the CBOR argument as a JS number — used for the length/count of major\n * types 2–5, where {@link readArgument}'s bigint would immediately be\n * converted back via Number().  Avoids a BigInt allocation per non-immediate\n * header on the decode hot path.\n *\n * An 8-byte argument ≥ 2^53 loses precision exactly as Number(bigint) would\n * (both round to nearest double); such lengths always exceed any real input,\n * so the subsequent bounds check fails identically either way.\n */\nfunction readLength(\n  view: DataView,\n  offset: number,\n  ai: number\n): { value: number; nextOffset: number } {\n  if (ai <= 23) {\n    return { value: ai, nextOffset: offset };\n  }\n  switch (ai) {\n    case AI_1BYTE:\n      if (offset + 1 > view.byteLength) decodeError('unexpected end of input');\n      return { value: view.getUint8(offset), nextOffset: offset + 1 };\n    case AI_2BYTE:\n      if (offset + 2 > view.byteLength) decodeError('unexpected end of input');\n      return { value: view.getUint16(offset, false), nextOffset: offset + 2 };\n    case AI_4BYTE:\n      if (offset + 4 > view.byteLength) decodeError('unexpected end of input');\n      return { value: view.getUint32(offset, false), nextOffset: offset + 4 };\n    case AI_8BYTE: {\n      if (offset + 8 > view.byteLength) decodeError('unexpected end of input');\n      const hi = view.getUint32(offset, false);\n      const lo = view.getUint32(offset + 4, false);\n      return { value: hi * 0x1_0000_0000 + lo, nextOffset: offset + 8 };\n    }\n    default:\n      decodeError(`reserved additional info value: ${ai}`);\n  }\n}\n\n// ─── Core recursive decoder ───────────────────────────────────────────────────\n\ntype DecodeResult = { value: CborItem; nextOffset: number };\n\n/**\n * Decode the chunks of an indefinite-length string (major type 2 or 3) up to\n * and including the \"break\" code.  `what` is used in error messages and\n * `isChunk` enforces that every chunk is a definite string of that type.\n */\nfunction decodeIndefiniteChunks<T extends CborItem>(\n  view: DataView,\n  offset: number,\n  options: FromCBOROptions | undefined,\n  tagExts: readonly CborExtension[],\n  what: 'byte string' | 'text string',\n  isChunk: (item: CborItem) => item is T\n): { chunks: T[]; nextOffset: number } {\n  const chunks: T[] = [];\n  let pos = offset;\n  while (true) {\n    if (pos >= view.byteLength)\n      decodeError(`unexpected end of indefinite ${what}`);\n    if (view.getUint8(pos) === BREAK_CODE) {\n      pos++;\n      break;\n    }\n    const result = decodeItem(view, pos, options, tagExts);\n    if (!isChunk(result.value))\n      decodeError(`indefinite-length ${what} chunk must be a definite ${what}`);\n    chunks.push(result.value);\n    pos = result.nextOffset;\n  }\n  return { chunks, nextOffset: pos };\n}\n\n/**\n * Record a duplicate-key strict violation if `key` was already seen.\n * Mutates `seenKeys` and appends any non-strict-mode warning to `warnings`.\n */\nfunction checkDuplicateKey(\n  key: CborItem,\n  seenKeys: Set<string>,\n  warnings: DecodeWarning[],\n  options: FromCBOROptions | undefined\n): void {\n  const fp = fingerprintKey(key);\n  if (seenKeys.has(fp)) {\n    warnings.push(\n      strictViolation(\n        `duplicate map key at offset ${key.start}`,\n        key.start!,\n        options\n      )\n    );\n  }\n  seenKeys.add(fp);\n}\n\nfunction decodeItem(\n  view: DataView,\n  offset: number,\n  options: FromCBOROptions | undefined,\n  tagExts: readonly CborExtension[]\n): DecodeResult {\n  const startOffset = offset;\n  const result = decodeItemInner(view, offset, options, tagExts);\n  result.value.start = startOffset;\n  result.value.end = result.nextOffset;\n  return result;\n}\n\n/**\n * Copy a float's encoded payload bytes out of the input, so NaN payloads\n * survive a decode → encode round-trip (see `CborFloat.rawBits`).\n */\nfunction floatPayloadBytes(\n  view: DataView,\n  offset: number,\n  length: number\n): Uint8Array {\n  return new Uint8Array(view.buffer, view.byteOffset + offset, length).slice();\n}\n\nfunction decodeItemInner(\n  view: DataView,\n  offset: number,\n  options: FromCBOROptions | undefined,\n  tagExts: readonly CborExtension[]\n): DecodeResult {\n  if (offset >= view.byteLength) decodeError('unexpected end of input');\n\n  const initialByte = view.getUint8(offset++);\n  const mt = initialByte >> 5;\n  const ai = initialByte & 0x1f;\n\n  switch (mt) {\n    // ── Major Type 0: unsigned integer ────────────────────────────────────────\n    case MT_UINT: {\n      const { value, nextOffset } = readArgument(view, offset, ai);\n      const encodingWidth = aiToNonCanonicalEW(ai, value);\n      return { value: new CborUint(value, { encodingWidth }), nextOffset };\n    }\n\n    // ── Major Type 1: negative integer ───────────────────────────────────────\n    case MT_NINT: {\n      const { value, nextOffset } = readArgument(view, offset, ai);\n      const encodingWidth = aiToNonCanonicalEW(ai, value);\n      // CBOR encodes negative integers as -1 - argument\n      return {\n        value: new CborNint(-1n - value, { encodingWidth }),\n        nextOffset,\n      };\n    }\n\n    // ── Major Type 2: byte string ─────────────────────────────────────────────\n    case MT_BYTES: {\n      if (ai === AI_INDEFINITE) {\n        const { chunks, nextOffset } = decodeIndefiniteChunks(\n          view,\n          offset,\n          options,\n          tagExts,\n          'byte string',\n          (item): item is CborByteString => item instanceof CborByteString\n        );\n        return { value: new CborIndefiniteByteString(chunks), nextOffset };\n      }\n      const { value: length, nextOffset: dataOffset } = readLength(\n        view,\n        offset,\n        ai\n      );\n      const encodingWidth = aiToNonCanonicalEWLen(ai, length);\n      if (dataOffset + length > view.byteLength)\n        decodeError('byte string extends beyond input');\n      const bytes = new Uint8Array(\n        view.buffer,\n        view.byteOffset + dataOffset,\n        length\n      );\n      return {\n        value: new CborByteString(bytes.slice(), { encodingWidth }),\n        nextOffset: dataOffset + length,\n      };\n    }\n\n    // ── Major Type 3: text string ─────────────────────────────────────────────\n    case MT_TEXT: {\n      if (ai === AI_INDEFINITE) {\n        const { chunks, nextOffset } = decodeIndefiniteChunks(\n          view,\n          offset,\n          options,\n          tagExts,\n          'text string',\n          (item): item is CborTextString => item instanceof CborTextString\n        );\n        return { value: new CborIndefiniteTextString(chunks), nextOffset };\n      }\n      const { value: length, nextOffset: dataOffset } = readLength(\n        view,\n        offset,\n        ai\n      );\n      const encodingWidth = aiToNonCanonicalEWLen(ai, length);\n      if (dataOffset + length > view.byteLength)\n        decodeError('text string extends beyond input');\n      const bytes = new Uint8Array(\n        view.buffer,\n        view.byteOffset + dataOffset,\n        length\n      );\n      let text: string;\n      let utf8Warning: DecodeWarning | undefined;\n      // Fast path: short pure-ASCII strings (map keys, identifiers) avoid\n      // TextDecoder overhead. Capped at 64 bytes to prevent double-scanning\n      // long buffers that turn out to contain non-ASCII bytes.\n      const asciiText = length < 64 ? tryDecodeAscii(bytes, length) : undefined;\n      if (asciiText !== undefined) {\n        text = asciiText;\n      } else {\n        try {\n          text = textDecoderStrict.decode(bytes);\n        } catch {\n          utf8Warning = strictViolation(\n            'invalid UTF-8 sequence in text string',\n            dataOffset,\n            options\n          );\n          // Only reached in non-strict mode — decode with replacement characters\n          text = textDecoderLenient.decode(bytes);\n        }\n      }\n      const textNode = new CborTextString(text, { encodingWidth });\n      if (utf8Warning) addWarning(textNode, utf8Warning);\n      return { value: textNode, nextOffset: dataOffset + length };\n    }\n\n    // ── Major Type 4: array ───────────────────────────────────────────────────\n    case MT_ARRAY: {\n      if (ai === AI_INDEFINITE) {\n        const items: CborItem[] = [];\n        let pos = offset;\n        while (true) {\n          if (pos >= view.byteLength)\n            decodeError('unexpected end of indefinite array');\n          if (view.getUint8(pos) === BREAK_CODE) {\n            pos++;\n            break;\n          }\n          const result = decodeItem(view, pos, options, tagExts);\n          items.push(result.value);\n          pos = result.nextOffset;\n        }\n        return {\n          value: new CborArray(items, { indefiniteLength: true }),\n          nextOffset: pos,\n        };\n      }\n      const { value: length, nextOffset: itemsStart } = readLength(\n        view,\n        offset,\n        ai\n      );\n      const encodingWidth = aiToNonCanonicalEWLen(ai, length);\n      const items: CborItem[] = [];\n      let pos = itemsStart;\n      for (let i = 0; i < length; i++) {\n        const result = decodeItem(view, pos, options, tagExts);\n        items.push(result.value);\n        pos = result.nextOffset;\n      }\n      return {\n        value: new CborArray(items, { encodingWidth }),\n        nextOffset: pos,\n      };\n    }\n\n    // ── Major Type 5: map ─────────────────────────────────────────────────────\n    case MT_MAP: {\n      if (ai === AI_INDEFINITE) {\n        const entries: [CborItem, CborItem][] = [];\n        const seenKeysIndef = new Set<string>();\n        const indefMapWarnings: DecodeWarning[] = [];\n        let pos = offset;\n        while (true) {\n          if (pos >= view.byteLength)\n            decodeError('unexpected end of indefinite map');\n          if (view.getUint8(pos) === BREAK_CODE) {\n            pos++;\n            break;\n          }\n          const keyResult = decodeItem(view, pos, options, tagExts);\n          checkDuplicateKey(\n            keyResult.value,\n            seenKeysIndef,\n            indefMapWarnings,\n            options\n          );\n          pos = keyResult.nextOffset;\n          const valResult = decodeItem(view, pos, options, tagExts);\n          pos = valResult.nextOffset;\n          entries.push([keyResult.value, valResult.value]);\n        }\n        const indefMapNode = new CborMap(entries, { indefiniteLength: true });\n        for (const w of indefMapWarnings) addWarning(indefMapNode, w);\n        return { value: indefMapNode, nextOffset: pos };\n      }\n      const { value: length, nextOffset: entriesStart } = readLength(\n        view,\n        offset,\n        ai\n      );\n      const encodingWidth = aiToNonCanonicalEWLen(ai, length);\n      const entries: [CborItem, CborItem][] = [];\n      const seenKeys = new Set<string>();\n      const mapWarnings: DecodeWarning[] = [];\n      let pos = entriesStart;\n      for (let i = 0; i < length; i++) {\n        const keyResult = decodeItem(view, pos, options, tagExts);\n        checkDuplicateKey(keyResult.value, seenKeys, mapWarnings, options);\n        pos = keyResult.nextOffset;\n        const valResult = decodeItem(view, pos, options, tagExts);\n        pos = valResult.nextOffset;\n        entries.push([keyResult.value, valResult.value]);\n      }\n      const mapNode = new CborMap(entries, { encodingWidth });\n      for (const w of mapWarnings) addWarning(mapNode, w);\n      return { value: mapNode, nextOffset: pos };\n    }\n\n    // ── Major Type 6: tagged item ─────────────────────────────────────────────\n    case MT_TAG: {\n      if (ai === AI_INDEFINITE)\n        decodeError('tags cannot use indefinite-length encoding');\n      const { value: tagNum, nextOffset: contentStart } = readArgument(\n        view,\n        offset,\n        ai\n      );\n      const tagEncodingWidth = aiToNonCanonicalEW(ai, tagNum);\n      const contentResult = decodeItem(view, contentStart, options, tagExts);\n      for (const ext of tagExts) {\n        const result = ext.parseTag!(tagNum, contentResult.value, options);\n        if (result !== undefined) {\n          if (result instanceof CborTag && tagEncodingWidth !== undefined)\n            result.encodingWidth = tagEncodingWidth;\n          return { value: result, nextOffset: contentResult.nextOffset };\n        }\n      }\n      return {\n        value: new CborTag(tagNum, contentResult.value, {\n          encodingWidth: tagEncodingWidth,\n        }),\n        nextOffset: contentResult.nextOffset,\n      };\n    }\n\n    // ── Major Type 7: float / simple value ────────────────────────────────────\n    case MT_SIMPLE: {\n      // ai 0–19: simple value encoded inline\n      if (ai <= 19) {\n        return { value: new CborSimple(ai), nextOffset: offset };\n      }\n      // ai 20–23: false / true / null / undefined\n      // Use new instances (not the static singletons) so that decodeItem() can\n      // safely set byte-offset properties without corrupting any concurrently\n      // live CDN AST that shares the same singleton.\n      if (ai === 20) return { value: new CborSimple(20), nextOffset: offset };\n      if (ai === 21) return { value: new CborSimple(21), nextOffset: offset };\n      if (ai === 22) return { value: new CborSimple(22), nextOffset: offset };\n      if (ai === 23) return { value: new CborSimple(23), nextOffset: offset };\n\n      // ai 24: simple value in next byte (value must be >= 32)\n      if (ai === AI_1BYTE) {\n        if (offset + 1 > view.byteLength)\n          decodeError('unexpected end of input');\n        const simpleVal = view.getUint8(offset);\n        if (simpleVal < 32) {\n          const w = strictViolation(\n            `simple value ${simpleVal} must be encoded in initial byte (0–31 reserved for extended encoding)`,\n            offset - 1,\n            options\n          );\n          // Only reached in non-strict mode — decode the value as-is\n          const simpleNode = new CborSimple(simpleVal);\n          addWarning(simpleNode, w);\n          return { value: simpleNode, nextOffset: offset + 1 };\n        }\n        return { value: new CborSimple(simpleVal), nextOffset: offset + 1 };\n      }\n\n      // ai 25: half-precision float\n      if (ai === AI_2BYTE) {\n        if (offset + 2 > view.byteLength)\n          decodeError('unexpected end of input');\n        const bits = view.getUint16(offset, false);\n        const value = float16BitsToFloat64(bits);\n        return {\n          value: new CborFloat(value, {\n            precision: 'half',\n            rawBits: Number.isNaN(value)\n              ? floatPayloadBytes(view, offset, 2)\n              : undefined,\n          }),\n          nextOffset: offset + 2,\n        };\n      }\n\n      // ai 26: single-precision float\n      if (ai === AI_4BYTE) {\n        if (offset + 4 > view.byteLength)\n          decodeError('unexpected end of input');\n        const value = view.getFloat32(offset, false);\n        return {\n          value: new CborFloat(value, {\n            precision: 'single',\n            rawBits: Number.isNaN(value)\n              ? floatPayloadBytes(view, offset, 4)\n              : undefined,\n          }),\n          nextOffset: offset + 4,\n        };\n      }\n\n      // ai 27: double-precision float\n      if (ai === AI_8BYTE) {\n        if (offset + 8 > view.byteLength)\n          decodeError('unexpected end of input');\n        const value = view.getFloat64(offset, false);\n        return {\n          value: new CborFloat(value, {\n            precision: 'double',\n            rawBits: Number.isNaN(value)\n              ? floatPayloadBytes(view, offset, 8)\n              : undefined,\n          }),\n          nextOffset: offset + 8,\n        };\n      }\n\n      // ai 28–30: reserved\n      if (ai < AI_INDEFINITE) {\n        decodeError(`reserved additional info value in major type 7: ${ai}`);\n      }\n\n      // ai 31: break code — not valid at item level\n      return decodeError(\n        'unexpected break code outside indefinite-length item'\n      );\n    }\n  }\n  // unreachable: all major types 0–7 are handled above\n  return decodeError(`unknown major type: ${mt}`);\n}\n\n// ─── Public API ───────────────────────────────────────────────────────────────\n\nfunction toInputBytes(data: ArrayBufferView | ArrayBufferLike): Uint8Array {\n  if (\n    data instanceof ArrayBuffer ||\n    (typeof SharedArrayBuffer !== 'undefined' &&\n      data instanceof SharedArrayBuffer)\n  ) {\n    return new Uint8Array(data);\n  }\n  if (ArrayBuffer.isView(data)) {\n    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  }\n  throw new TypeError('expected ArrayBufferView or ArrayBufferLike');\n}\n\n/**\n * Decode a CBOR-encoded byte array into a CborItem AST node.\n *\n * Accepts any `ArrayBufferView` (e.g. `Uint8Array`, `DataView`) or\n * `ArrayBufferLike` (e.g. `ArrayBuffer`, `SharedArrayBuffer`).\n *\n * Throws if the input is not well-formed CBOR or contains trailing bytes.\n */\nexport function decodeCBOR(\n  input: ArrayBufferView | ArrayBufferLike,\n  options?: FromCBOROptions\n): CborItem {\n  const bytes = toInputBytes(input);\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  const offset = options?.offset ?? 0;\n  if (!Number.isInteger(offset) || offset < 0 || offset > view.byteLength) {\n    throw new RangeError(\n      `CBOR decode offset must be an integer between 0 and ${view.byteLength}`\n    );\n  }\n  // Build the tag-extension list once per decode call.\n  // For the common case (no user extensions) reuse the pre-filtered module-level\n  // constant to avoid a spread + filter allocation on every decode call.\n  const builtinTagExts = getBuiltinTagExts(options?.builtinExtensions);\n  const tagExts = options?.extensions?.length\n    ? [\n        ...options.extensions.filter((e) => e.parseTag !== undefined),\n        ...builtinTagExts,\n      ]\n    : builtinTagExts;\n  const { value, nextOffset } = decodeItem(view, offset, options, tagExts);\n  if (!options?.allowTrailing && nextOffset !== view.byteLength) {\n    const w = strictViolation(\n      `${view.byteLength - nextOffset} trailing byte(s) after end of CBOR item`,\n      nextOffset,\n      options\n    );\n    // Only reached in non-strict mode (strictViolation throws in strict mode).\n    addWarning(value, w);\n    // Scan the trailing bytes so that truly malformed trailing items\n    // (e.g. truncated input, reserved additional-info values) still throw,\n    // even though the leading item decoded successfully.\n    const scanOpts: FromCBOROptions = { strict: false, silent: true };\n    let pos = nextOffset;\n    while (pos < view.byteLength) {\n      ({ nextOffset: pos } = decodeItem(view, pos, scanOpts, tagExts));\n    }\n  }\n  return value;\n}\n","/**\n * Built-in embedded CBOR extension (RFC 8949 §3.4.5.1).\n *\n * Intercepts tag 24 during fromCBOR() so that the byte string content is\n * decoded as a CBOR data item and represented as CborEmbeddedCBOR.  This\n * allows toCDN() to render the value as 24(<<item>>) instead of 24(h'...').\n *\n * If the byte string is not valid CBOR (or has trailing bytes), the extension\n * returns undefined and falls back to the plain CborTag representation.\n */\n\nimport type { CborExtension } from './types';\nimport type { CborItem } from '../ast/CborItem';\nimport type { DecodeWarning, FromCBOROptions } from '../types';\nimport { CborByteString } from '../ast/CborByteString';\nimport { CborEmbeddedCBOR } from '../ast/CborEmbeddedCBOR';\nimport { CborTag } from '../ast/CborTag';\nimport { decodeCBOR } from '../cbor/decoder';\n\nexport const TAG_CBOR_DATA = 24n;\n\nconst cbordata: CborExtension = {\n  tagNumbers: [TAG_CBOR_DATA],\n\n  parseTag(\n    tag: bigint,\n    value: CborItem,\n    options?: FromCBOROptions\n  ): CborItem | undefined {\n    if (tag !== TAG_CBOR_DATA) return undefined;\n    if (!(value instanceof CborByteString)) return undefined;\n    // The embedded bytes are decoded as a fresh buffer starting at offset 0,\n    // so any offset reported by the inner decode (via onWarning, or a thrown\n    // error) is relative to that buffer and must be translated back to the\n    // payload's actual position in the outer input before it reaches callers.\n    const payloadStart = (value.end ?? value.value.length) - value.value.length;\n    // Forward strict/silent/builtinExtensions into the inner decode, but\n    // reset offset and allowTrailing since the embedded bytes start at 0.\n    // Forwarding builtinExtensions matters for the allowlist story: a\n    // disabled built-in (e.g. dt via builtinExtensions: false) must not\n    // re-enable itself for tags found inside embedded CBOR.\n    const innerOptions: FromCBOROptions | undefined = options\n      ? {\n          extensions: options.extensions,\n          builtinExtensions: options.builtinExtensions,\n          strict: options.strict,\n          onWarning: options.onWarning\n            ? (w: DecodeWarning) =>\n                options.onWarning!({ ...w, offset: w.offset + payloadStart })\n            : undefined,\n          silent: options.silent,\n        }\n      : undefined;\n    try {\n      const decoded = decodeCBOR(value.value, innerOptions);\n      return new CborTag(\n        TAG_CBOR_DATA,\n        new CborEmbeddedCBOR([decoded], { encodingWidth: value.encodingWidth })\n      );\n    } catch (e) {\n      if (innerOptions?.strict !== false) {\n        // In strict mode, propagate inner violations to the outer decode.\n        throw e;\n      }\n      // In non-strict mode, fall back to a plain CborTag, but still surface\n      // the violation via onWarning — otherwise callers that rely on it to\n      // detect problems (e.g. CBOR.validate()) would see no signal at all\n      // for tag 24 content that isn't valid CBOR.\n      const message = `tag 24 content is not valid CBOR: ${\n        e instanceof Error ? e.message : String(e)\n      }`;\n      const warning: DecodeWarning = { message, offset: payloadStart };\n      if (options?.onWarning) {\n        options.onWarning(warning);\n      } else if (!options?.silent) {\n        console.warn(\n          `CBOR strict violation at offset ${warning.offset}: ${message}`\n        );\n      }\n      return undefined;\n    }\n  },\n};\n\nexport default cbordata;\n","/**\n * Core decode support for the CPA888 ellipsis (elision) tag (§4.2 of\n * draft-ietf-cbor-edn-literals-26).\n *\n * Intercepts tag 888 during fromCBOR() and integer-tagged EDN parsing so\n * that elided items decode back to CborEllipsis and round-trip as `...`\n * notation instead of `888(null)` / `888([...])`.\n *\n * Ellipsis is core EDN syntax (the CDN parser handles `...` directly, not\n * via an app-string extension), so this lives in CORE_EXTENSIONS and is not\n * affected by the `builtinExtensions` option.\n */\n\nimport type { CborExtension } from './types';\nimport type { CborItem } from '../ast/CborItem';\nimport { CborEllipsis, CPA888_TAG } from '../ast/CborEllipsis';\nimport { CborArray } from '../ast/CborArray';\nimport { CborSimple } from '../ast/CborSimple';\nimport { CborTextString } from '../ast/CborTextString';\nimport { CborByteString } from '../ast/CborByteString';\n\n/** Subtree elision marker: 888(null), already reconstructed bottom-up. */\nfunction isSubtreeEllipsis(item: CborItem): boolean {\n  return item instanceof CborEllipsis && !(item.content instanceof CborArray);\n}\n\n/**\n * A well-formed string-elision array: string fragments of a single kind\n * (all text or all byte) strictly alternating with at least one subtree\n * ellipsis (`h'...'` yields the single-item form `888([888(null)])`).\n * Any other shape stays a plain CborTag — a lenient reconstruction (e.g. of\n * adjacent fragments or adjacent ellipses) would not re-parse to the same\n * data item.\n */\nfunction isElisionArray(items: readonly CborItem[]): boolean {\n  let text = false;\n  let byte = false;\n  let sawEllipsis = false;\n  let prevWasEllipsis: boolean | undefined;\n  for (const item of items) {\n    let isEllipsis: boolean;\n    if (isSubtreeEllipsis(item)) {\n      isEllipsis = true;\n      sawEllipsis = true;\n    } else if (item instanceof CborTextString) {\n      isEllipsis = false;\n      text = true;\n    } else if (item instanceof CborByteString) {\n      isEllipsis = false;\n      byte = true;\n    } else {\n      return false;\n    }\n    if (isEllipsis === prevWasEllipsis) return false; // no strict alternation\n    prevWasEllipsis = isEllipsis;\n  }\n  return sawEllipsis && !(text && byte); // fragments must be homogeneous\n}\n\nexport const ellipsis: CborExtension = {\n  tagNumbers: [CPA888_TAG],\n\n  parseTag(tag: bigint, value: CborItem): CborItem | undefined {\n    if (tag !== CPA888_TAG) return undefined;\n    if (value instanceof CborSimple && value.value === 22)\n      return new CborEllipsis();\n    if (value instanceof CborArray && isElisionArray(value.items))\n      return new CborEllipsis(value.items);\n    return undefined;\n  },\n};\n\nexport default ellipsis;\n","/**\n * `t1'...'` / `t1<<...>>` and `b1'...'` / `b1<<...>>` string-concatenation\n * app-extensions (§3.4 of draft-ietf-cbor-edn-literals-26).\n *\n * Builds a single (text or byte) string by joining the bytes of the (text or\n * byte) string arguments from left to right:\n *   - `t1` produces a text string; the joined bytes must be valid UTF-8.\n *   - `b1` produces a byte string.\n * Text and byte strings can mix within one concatenation.\n *\n * Arguments may include ellipses (`...`); the result is then an ellipsis\n * data item — tag CPA888 wrapping an array of joined string spans\n * alternating with `888(null)` markers (§4.2).  Adjacent ellipses collapse\n * into one, and nested ellipsis arguments are flattened.\n *\n * `t1` and `b1` are mandatory-to-implement in draft-26 and are included in\n * the default extension set.\n *\n * NOTE: the identifiers \"t1\" and \"b1\" are explicitly provisional in\n * draft-26 (§3.4) and may be renamed by the CBOR WG.\n */\n\nimport type { CborExtension } from './types';\nimport type { CborItem } from '../ast/CborItem';\nimport { CborTextString } from '../ast/CborTextString';\nimport { CborByteString } from '../ast/CborByteString';\nimport { CborIndefiniteTextString } from '../ast/CborIndefiniteTextString';\nimport { CborIndefiniteByteString } from '../ast/CborIndefiniteByteString';\nimport { CborEllipsis } from '../ast/CborEllipsis';\nimport { CborAppSeqResult } from '../ast/CborAppSeqResult';\nimport { CborArray } from '../ast/CborArray';\n\nconst textEncoder = new TextEncoder();\nconst utf8Strict = new TextDecoder('utf-8', { fatal: true });\nconst utf8Lenient = new TextDecoder('utf-8', { fatal: false });\n\n/** Marker for an elision within the flattened argument list. */\nconst ELLIPSIS = Symbol('ellipsis');\ntype Part = Uint8Array | typeof ELLIPSIS;\n\nfunction concatBytes(parts: Uint8Array[]): Uint8Array {\n  let total = 0;\n  for (const p of parts) total += p.length;\n  const out = new Uint8Array(total);\n  let offset = 0;\n  for (const p of parts) {\n    out.set(p, offset);\n    offset += p.length;\n  }\n  return out;\n}\n\n/**\n * Flatten one argument into byte spans and ellipsis markers.\n * Nested ellipsis items (e.g. from `h'aa...bb'` arguments) are expanded so\n * that the equivalences of §3.4 hold.\n */\nfunction flattenArg(prefix: string, item: CborItem, parts: Part[]): void {\n  if (item instanceof CborAppSeqResult) {\n    flattenArg(prefix, item.inner, parts);\n    return;\n  }\n  if (item instanceof CborEllipsis) {\n    if (item.content instanceof CborArray) {\n      for (const inner of item.content.items) flattenArg(prefix, inner, parts);\n    } else {\n      parts.push(ELLIPSIS);\n    }\n    return;\n  }\n  if (item instanceof CborTextString) {\n    parts.push(textEncoder.encode(item.value));\n    return;\n  }\n  if (item instanceof CborByteString) {\n    parts.push(item.value);\n    return;\n  }\n  if (item instanceof CborIndefiniteTextString) {\n    parts.push(textEncoder.encode(item.chunks.map((c) => c.value).join('')));\n    return;\n  }\n  if (item instanceof CborIndefiniteByteString) {\n    parts.push(concatBytes(item.chunks.map((c) => c.value)));\n    return;\n  }\n  throw new SyntaxError(\n    `${prefix}<<...>> arguments must be (text or byte) strings or ellipses`\n  );\n}\n\n/** Decode joined bytes as UTF-8; recoverable violation when invalid. */\nfunction decodeText(\n  bytes: Uint8Array,\n  onError: ((msg: string) => void) | undefined\n): string {\n  try {\n    return utf8Strict.decode(bytes);\n  } catch {\n    const msg = `t1 concatenation result is not valid UTF-8`;\n    if (onError) onError(msg);\n    else throw new SyntaxError(msg);\n    return utf8Lenient.decode(bytes);\n  }\n}\n\nfunction concatenate(\n  prefix: string,\n  items: CborItem[],\n  onError?: (msg: string) => void\n): CborItem {\n  const parts: Part[] = [];\n  for (const item of items) flattenArg(prefix, item, parts);\n\n  const isText = prefix === 't1';\n\n  // Consolidate adjacent byte spans; collapse adjacent ellipses (§3.4).\n  const fragments: CborItem[] = [];\n  let hasEllipsis = false;\n  const pending: Uint8Array[] = [];\n  const flushPending = () => {\n    if (pending.length === 0) return;\n    const bytes = concatBytes(pending);\n    pending.length = 0;\n    if (bytes.length === 0) return; // empty spans add nothing to the 888 array\n    fragments.push(\n      isText\n        ? new CborTextString(decodeText(bytes, onError))\n        : new CborByteString(bytes)\n    );\n  };\n  for (const part of parts) {\n    if (part === ELLIPSIS) {\n      flushPending();\n      if (!(fragments[fragments.length - 1] instanceof CborEllipsis)) {\n        fragments.push(new CborEllipsis());\n        hasEllipsis = true;\n      }\n    } else {\n      pending.push(part);\n    }\n  }\n\n  if (!hasEllipsis) {\n    const bytes = concatBytes(pending);\n    return isText\n      ? new CborTextString(decodeText(bytes, onError))\n      : new CborByteString(bytes);\n  }\n  flushPending();\n\n  // A lone ellipsis argument list is equivalent to a single ellipsis.\n  if (fragments.length === 1) return new CborEllipsis();\n  return new CborEllipsis(fragments);\n}\n\nfunction makeExtension(prefix: 't1' | 'b1'): CborExtension {\n  return {\n    appStringPrefixes: [prefix],\n    preserveAppSeqSource: true,\n\n    // prefix'...' / prefix`...` is shorthand for a sequence with exactly\n    // that one text string (§2.1).\n    parseAppString(_prefix, content, onError) {\n      return concatenate(prefix, [new CborTextString(content)], onError);\n    },\n\n    parseAppSequence(_prefix, items, onError) {\n      return concatenate(prefix, items, onError);\n    },\n  };\n}\n\n/** Extension object for `t1'...'` / `t1<<...>>` (text-string concatenation). */\nexport const t1: CborExtension = makeExtension('t1');\n\n/** Extension object for `b1'...'` / `b1<<...>>` (byte-string concatenation). */\nexport const b1: CborExtension = makeExtension('b1');\n","/**\n * `ilbs'...'` / `ilbs<<...>>` and `ilts'...'` / `ilts<<...>>` app-extensions\n * (§3.5 of draft-ietf-cbor-edn-literals-26) — build indefinite-length\n * encoded strings.\n *\n * Semantically identical to `b1` / `t1` at the data model level, but instead\n * of concatenating the arguments into a single string, one chunk is created\n * per argument:\n *   - `ilbs` produces an indefinite-length byte string (byte chunks),\n *   - `ilts` produces an indefinite-length text string (text chunks).\n *\n * Encoding indicators on individual arguments are honored — the chunk keeps\n * the same encoding (e.g. `ilbs<<'Hello '_0, 'world'>>` → `5f 5806 ... ff`).\n * An indefinite-length string argument (e.g. a legacy `(_ ...)` streamstring)\n * is a string at the data model level and contributes one chunk with its\n * merged value.  Ellipses cannot be used: there is no way to include an\n * elision in an indefinite-length string.\n *\n * These extensions replace the now-deprecated `(_ chunk, ...)` streamstring\n * syntax for new CDN documents (§2.5.5); this library keeps accepting the\n * legacy syntax on input.\n */\n\nimport type { CborExtension } from './types';\nimport type { CborItem } from '../ast/CborItem';\nimport type { EncodingWidth } from '../cbor/encode';\nimport { CborTextString } from '../ast/CborTextString';\nimport { CborByteString } from '../ast/CborByteString';\nimport { CborIndefiniteTextString } from '../ast/CborIndefiniteTextString';\nimport { CborIndefiniteByteString } from '../ast/CborIndefiniteByteString';\nimport { CborEllipsis } from '../ast/CborEllipsis';\nimport { CborAppSeqResult } from '../ast/CborAppSeqResult';\nimport { escapeAppString } from '../cdn/serialize-utils';\n\nconst textEncoder = new TextEncoder();\nconst utf8Strict = new TextDecoder('utf-8', { fatal: true });\nconst utf8Lenient = new TextDecoder('utf-8', { fatal: false });\n\nfunction concatBytes(parts: Uint8Array[]): Uint8Array {\n  let total = 0;\n  for (const p of parts) total += p.length;\n  const out = new Uint8Array(total);\n  let offset = 0;\n  for (const p of parts) {\n    out.set(p, offset);\n    offset += p.length;\n  }\n  return out;\n}\n\nfunction buildIndefinite(\n  prefix: string,\n  items: CborItem[],\n  onError?: (msg: string) => void\n): CborItem {\n  const isText = prefix === 'ilts';\n  const byteChunks: CborByteString[] = [];\n  const textChunks: CborTextString[] = [];\n\n  for (let item of items) {\n    if (item instanceof CborAppSeqResult) item = item.inner;\n    if (item instanceof CborEllipsis)\n      throw new SyntaxError(\n        `${prefix}<<...>> cannot contain ellipses; there is no way to include an elision in an indefinite-length string`\n      );\n\n    // Normalize the argument to its data-model string value.  Indefinite-\n    // length string arguments (e.g. a legacy `(_ ...)` streamstring) are\n    // strings at the data model level; their merged value becomes one chunk.\n    let argText: string | undefined;\n    let argBytes: Uint8Array | undefined;\n    // Encoding indicators are only carried by definite-length arguments.\n    let ew: EncodingWidth | undefined;\n    if (item instanceof CborTextString) {\n      argText = item.value;\n      ew = item.encodingWidth;\n    } else if (item instanceof CborByteString) {\n      argBytes = item.value;\n      ew = item.encodingWidth;\n    } else if (item instanceof CborIndefiniteTextString) {\n      argText = item.chunks.map((c) => c.value).join('');\n    } else if (item instanceof CborIndefiniteByteString) {\n      argBytes = concatBytes(item.chunks.map((c) => c.value));\n    } else {\n      throw new SyntaxError(\n        `${prefix}<<...>> arguments must be (text or byte) strings`\n      );\n    }\n\n    // One chunk per argument, keeping the argument's encoding indicator.\n    if (isText) {\n      let text: string;\n      if (argText !== undefined) {\n        text = argText;\n      } else {\n        try {\n          text = utf8Strict.decode(argBytes!);\n        } catch {\n          // RFC 8949 §3.2.3: each text-string chunk must itself be valid UTF-8.\n          const msg = `ilts chunk is not valid UTF-8`;\n          if (onError) onError(msg);\n          else throw new SyntaxError(msg);\n          text = utf8Lenient.decode(argBytes!);\n        }\n      }\n      textChunks.push(\n        new CborTextString(\n          text,\n          ew !== undefined ? { encodingWidth: ew } : undefined\n        )\n      );\n    } else {\n      const bytes = argBytes ?? textEncoder.encode(argText!);\n      byteChunks.push(\n        new CborByteString(\n          bytes,\n          ew !== undefined ? { encodingWidth: ew } : undefined\n        )\n      );\n    }\n  }\n\n  return isText\n    ? new CborIndefiniteTextString(textChunks)\n    : new CborIndefiniteByteString(byteChunks);\n}\n\nfunction makeExtension(prefix: 'ilbs' | 'ilts'): CborExtension {\n  return {\n    appStringPrefixes: [prefix],\n    preserveAppSeqSource: true,\n\n    // prefix'...' / prefix`...` is shorthand for a sequence with exactly\n    // that one text string (§2.1) — the result has a single chunk.\n    // The result is wrapped so that toCDN() round-trips an app-string form\n    // instead of normalizing to the deprecated `(_ ...)` streamstring\n    // syntax.  The source is reconstructed from the content, so the raw\n    // string form prefix`...` normalizes to the single-quoted form.\n    parseAppString(_prefix, content, onError) {\n      const result = buildIndefinite(\n        prefix,\n        [new CborTextString(content)],\n        onError\n      );\n      return new CborAppSeqResult(\n        result,\n        `${prefix}${escapeAppString(content)}`\n      );\n    },\n\n    parseAppSequence(_prefix, items, onError) {\n      return buildIndefinite(prefix, items, onError);\n    },\n  };\n}\n\n/** Extension object for `ilbs<<...>>` (indefinite-length byte string). */\nexport const ilbs: CborExtension = makeExtension('ilbs');\n\n/** Extension object for `ilts<<...>>` (indefinite-length text string). */\nexport const ilts: CborExtension = makeExtension('ilts');\n","/**\n * `float'...'` / `float<<...>>` app-string extension.\n *\n * Interprets a hex bit-pattern as an IEEE 754 floating-point value:\n *   - 4 hex digits  (2 bytes) → float16  (CBOR major-7, additional 25 / 0xf9)\n *   - 8 hex digits  (4 bytes) → float32  (CBOR major-7, additional 26 / 0xfa)\n *   - 16 hex digits (8 bytes) → float64  (CBOR major-7, additional 27 / 0xfb)\n *\n * The string form `float'...'` supports the same comment syntax as `h'...'`:\n * slash-delimited block comments, C-style block comments, line comments (`//`\n * and `#`).  The extension strips comments from the raw content itself.\n *\n * The sequence form `float<<byteStr>>` accepts a single byte-string expression\n * (e.g. `float<<h'7ef0'>>`) and interprets its bytes as float bits.\n *\n * Defined in draft-ietf-cbor-edn-literals-26 §3.7 and included in the default\n * extension set:\n *\n * @example\n * parseCDN(\"float'7ef0'\"); // NaN as float16\n */\n\nimport type { CborExtension } from './types';\nimport type { CborItem } from '../ast/CborItem';\nimport { CborFloat } from '../ast/CborFloat';\nimport { CborByteString } from '../ast/CborByteString';\nimport { float16BitsToFloat64, float64ToFloat16Bits } from '../utils/float16';\nimport { stripComments } from '../utils/strip-comments';\nimport { hexToBytes } from '../utils/hex';\nimport type { EncodingWidth } from '../cbor/encode';\n\n// ── Bit-preserving CborFloat subclasses ───────────────────────────────────────\n// CborFloat stores a JS `number`, which loses NaN payloads.  These subclasses\n// override _toCBOR() to emit the original bit pattern verbatim.\n\nclass CborFloat16Bits extends CborFloat {\n  private readonly _bits: number;\n  constructor(bits: number) {\n    super(float16BitsToFloat64(bits), { precision: 'half' });\n    this._bits = bits & 0xffff;\n  }\n  override _toCBOR(): Uint8Array {\n    return new Uint8Array([0xf9, (this._bits >> 8) & 0xff, this._bits & 0xff]);\n  }\n}\n\nclass CborFloat32Bits extends CborFloat {\n  private readonly _raw: Uint8Array;\n  constructor(bytes: Uint8Array) {\n    super(new DataView(bytes.buffer, bytes.byteOffset).getFloat32(0, false), {\n      precision: 'single',\n    });\n    this._raw = bytes.slice();\n  }\n  override _toCBOR(): Uint8Array {\n    const out = new Uint8Array(5);\n    out[0] = 0xfa;\n    out.set(this._raw, 1);\n    return out;\n  }\n}\n\nclass CborFloat64Bits extends CborFloat {\n  private readonly _raw: Uint8Array;\n  constructor(bytes: Uint8Array) {\n    super(new DataView(bytes.buffer, bytes.byteOffset).getFloat64(0, false), {\n      precision: 'double',\n    });\n    this._raw = bytes.slice();\n  }\n  override _toCBOR(): Uint8Array {\n    const out = new Uint8Array(9);\n    out[0] = 0xfb;\n    out.set(this._raw, 1);\n    return out;\n  }\n}\n\nfunction floatFromBytes(bytes: Uint8Array): CborFloat {\n  if (bytes.length === 2) {\n    const bits = (bytes[0]! << 8) | bytes[1]!;\n    return new CborFloat16Bits(bits);\n  }\n  if (bytes.length === 4) return new CborFloat32Bits(bytes);\n  if (bytes.length === 8) return new CborFloat64Bits(bytes);\n  throw new SyntaxError(\n    `float'...' requires 4, 8, or 16 hex digits (2, 4, or 8 bytes); got ${bytes.length} bytes`\n  );\n}\n\n/** Expand float16 bit pattern to 4-byte float32 (bit-exact, preserves NaN payloads). */\nfunction float16BitsToFloat32Bytes(bits16: number): Uint8Array {\n  const sign = (bits16 >>> 15) & 1;\n  const exp16 = (bits16 >>> 10) & 0x1f;\n  const mant16 = bits16 & 0x3ff;\n  let bits32: number;\n  if (exp16 === 0x1f) {\n    bits32 = (sign << 31) | 0x7f800000 | (mant16 << 13);\n  } else if (exp16 === 0 && mant16 === 0) {\n    bits32 = sign << 31;\n  } else if (exp16 === 0) {\n    // Denormal float16 → normal float32\n    let m = mant16;\n    let shifts = 0;\n    while ((m & 0x200) === 0) {\n      m <<= 1;\n      shifts++;\n    }\n    bits32 = (sign << 31) | ((112 - shifts) << 23) | ((m & 0x1ff) << 14);\n  } else {\n    bits32 = (sign << 31) | ((exp16 + 112) << 23) | (mant16 << 13);\n  }\n  const out = new Uint8Array(4);\n  new DataView(out.buffer).setUint32(0, bits32 >>> 0, false);\n  return out;\n}\n\n/** Expand float16 bit pattern to 8-byte float64 (bit-exact, preserves NaN payloads). */\nfunction float16BitsToFloat64Bytes(bits16: number): Uint8Array {\n  const sign = (bits16 >>> 15) & 1;\n  const exp16 = (bits16 >>> 10) & 0x1f;\n  const mant16 = bits16 & 0x3ff;\n  const out = new Uint8Array(8);\n  const dv = new DataView(out.buffer);\n  if (exp16 === 0x1f) {\n    dv.setUint32(0, ((sign << 31) | 0x7ff00000 | (mant16 << 10)) >>> 0, false);\n    dv.setUint32(4, 0, false);\n  } else if (exp16 === 0 && mant16 === 0) {\n    dv.setUint32(0, (sign << 31) >>> 0, false);\n    dv.setUint32(4, 0, false);\n  } else if (exp16 === 0) {\n    // Denormal float16 → normal float64\n    let m = mant16;\n    let shifts = 0;\n    while ((m & 0x200) === 0) {\n      m <<= 1;\n      shifts++;\n    }\n    dv.setUint32(\n      0,\n      ((sign << 31) | ((1008 - shifts) << 20) | ((m & 0x1ff) << 11)) >>> 0,\n      false\n    );\n    dv.setUint32(4, 0, false);\n  } else {\n    dv.setUint32(\n      0,\n      ((sign << 31) | ((exp16 + 1008) << 20) | (mant16 << 10)) >>> 0,\n      false\n    );\n    dv.setUint32(4, 0, false);\n  }\n  return out;\n}\n\n/** Expand float32 bit pattern to 8-byte float64 (bit-exact, preserves NaN payloads). */\nfunction float32BitsToFloat64Bytes(bytes4: Uint8Array): Uint8Array {\n  const bits32 = new DataView(bytes4.buffer, bytes4.byteOffset).getUint32(\n    0,\n    false\n  );\n  const sign = (bits32 >>> 31) & 1;\n  const exp32 = (bits32 >>> 23) & 0xff;\n  const mant32 = bits32 & 0x7fffff;\n  const out = new Uint8Array(8);\n  const dv = new DataView(out.buffer);\n  if (exp32 === 0xff) {\n    dv.setUint32(0, ((sign << 31) | 0x7ff00000 | (mant32 >>> 3)) >>> 0, false);\n    dv.setUint32(4, (mant32 & 7) << 29, false);\n  } else if (exp32 === 0 && mant32 === 0) {\n    dv.setUint32(0, (sign << 31) >>> 0, false);\n    dv.setUint32(4, 0, false);\n  } else {\n    // Normal or denormal: JS arithmetic is exact (float32 ⊂ float64), NaN handled above.\n    const f64 = new DataView(bytes4.buffer, bytes4.byteOffset).getFloat32(\n      0,\n      false\n    );\n    dv.setFloat64(0, f64, false);\n  }\n  return out;\n}\n\n/**\n * Re-encode float bytes at a target precision (_1=half, _2=single, _3=double).\n * Returns undefined if the conversion is lossy (caller should warn).\n */\nfunction reencodeFloat(\n  bytes: Uint8Array,\n  targetWidth: 1 | 2 | 3,\n  onError: (msg: string) => void\n): CborFloat {\n  const naturalWidth = bytes.length === 2 ? 1 : bytes.length === 4 ? 2 : 3;\n\n  if (naturalWidth === 1) {\n    const bits16 = (bytes[0]! << 8) | bytes[1]!;\n    if (targetWidth === 2)\n      return new CborFloat32Bits(float16BitsToFloat32Bytes(bits16));\n    if (targetWidth === 3)\n      return new CborFloat64Bits(float16BitsToFloat64Bytes(bits16));\n  }\n\n  if (naturalWidth === 2) {\n    if (targetWidth === 3)\n      return new CborFloat64Bits(float32BitsToFloat64Bytes(bytes));\n    if (targetWidth === 1) {\n      const f32 = new DataView(bytes.buffer, bytes.byteOffset).getFloat32(\n        0,\n        false\n      );\n      const bits16 = float64ToFloat16Bits(f32);\n      if (!Object.is(float16BitsToFloat64(bits16), f32) && !isNaN(f32)) {\n        onError(\n          `float'...' value cannot be exactly represented as float16 (_1)`\n        );\n      }\n      return new CborFloat16Bits(bits16);\n    }\n  }\n\n  if (naturalWidth === 3) {\n    const f64 = new DataView(bytes.buffer, bytes.byteOffset).getFloat64(\n      0,\n      false\n    );\n    if (targetWidth === 1) {\n      const bits16 = float64ToFloat16Bits(f64);\n      if (!Object.is(float16BitsToFloat64(bits16), f64) && !isNaN(f64)) {\n        onError(\n          `float'...' value cannot be exactly represented as float16 (_1)`\n        );\n      }\n      return new CborFloat16Bits(bits16);\n    }\n    if (targetWidth === 2) {\n      const f32 = Math.fround(f64);\n      if (!Object.is(f32, f64) && !isNaN(f64)) {\n        onError(\n          `float'...' value cannot be exactly represented as float32 (_2)`\n        );\n      }\n      const out = new Uint8Array(4);\n      new DataView(out.buffer).setFloat32(0, f32, false);\n      return new CborFloat32Bits(out);\n    }\n  }\n\n  // naturalWidth === targetWidth: identity (already handled by caller)\n  return floatFromBytes(bytes);\n}\n\n/**\n * Extension object for `float'...'` / `float<<...>>`.\n * Pass to `parseCDN(..., { extensions: [float] })`.\n */\nexport const float: CborExtension = {\n  appStringPrefixes: ['float'],\n\n  parseAppString(\n    _prefix: string,\n    content: string,\n    onError?: (msg: string) => void,\n    options?: { encodingWidth?: EncodingWidth }\n  ): CborItem {\n    const hex = stripComments(content);\n    if (!/^[0-9a-fA-F]*$/.test(hex))\n      throw new SyntaxError(`float'...' contains non-hex characters`);\n    if (hex.length % 2 !== 0)\n      throw new SyntaxError(\n        `float'...' hex content has odd length (${hex.length} digits)`\n      );\n    const bytes = hexToBytes(hex);\n    const ew = options?.encodingWidth;\n    if (ew === undefined) return floatFromBytes(bytes);\n    if (ew !== 1 && ew !== 2 && ew !== 3) {\n      const msg = `float'...' encoding indicator _${ew} is not valid; use _1, _2, or _3`;\n      if (onError) {\n        onError(msg);\n        return floatFromBytes(bytes);\n      }\n      throw new SyntaxError(msg);\n    }\n    const naturalWidth = bytes.length === 2 ? 1 : bytes.length === 4 ? 2 : 3;\n    if (ew === naturalWidth) return floatFromBytes(bytes);\n    const fallbackOnError =\n      onError ??\n      ((msg: string) => {\n        throw new SyntaxError(msg);\n      });\n    return reencodeFloat(bytes, ew, fallbackOnError);\n  },\n\n  parseAppSequence(\n    _prefix: string,\n    items: CborItem[],\n    onError?: (msg: string) => void\n  ): CborItem {\n    if (items.length === 0)\n      throw new SyntaxError(\n        `float<<...>> requires exactly one byte-string item`\n      );\n    if (items.length > 1) {\n      const msg = `float<<...>> expects 1 item; got ${items.length} — using first`;\n      if (onError) onError(msg);\n      else throw new SyntaxError(msg);\n    }\n    if (!(items[0] instanceof CborByteString))\n      throw new SyntaxError(`float<<...>> item must be a byte string`);\n    return floatFromBytes(items[0].value);\n  },\n};\n\nexport default float;\n","import type { CborExtension } from './types';\nimport dt from './dt';\nimport ip from './ip';\nimport cri from './cri';\nimport bignum from './bignum';\nimport cbordata from './cbordata';\nimport ellipsis from './ellipsis';\nimport { t1, b1 } from './concat';\nimport { ilbs, ilts } from './ilstrings';\nimport float from './float';\n\n/**\n * Core data-model extensions (bignum tags 2/3, embedded-CBOR tag 24, and the\n * CPA888 ellipsis tag). These implement base CBOR/EDN representation rather\n * than an application-oriented extension, so they are always active and are\n * not affected by the `builtinExtensions` option.\n */\nexport const CORE_EXTENSIONS: readonly CborExtension[] = [\n  bignum,\n  cbordata,\n  ellipsis,\n];\n\n/**\n * Default application-oriented extensions bundled with the library.\n * Overridable per call via `builtinExtensions` (an array to use instead, or\n * `false` to disable all of them).\n *\n * `dt`, `ip`, `t1`, and `b1` are mandatory-to-implement per §2.1 of\n * draft-ietf-cbor-edn-literals-26; `cri`, `ilbs`, `ilts`, and `float` are\n * bundled but not mandatory.\n */\nexport const BUILTIN_EXTENSIONS: readonly CborExtension[] = [\n  dt,\n  ip,\n  cri,\n  t1,\n  b1,\n  ilbs,\n  ilts,\n  float,\n];\n\nlet _defaultResolved: readonly CborExtension[] | undefined;\n\n/**\n * Resolve the `builtinExtensions` option to the full list of built-in\n * extensions that should be active: `CORE_EXTENSIONS` plus either the\n * default `BUILTIN_EXTENSIONS` set (`undefined`), a caller-supplied\n * replacement array, or nothing beyond core (`false`).\n */\nexport function resolveBuiltinExtensions(\n  builtinExtensions?: CborExtension[] | false\n): readonly CborExtension[] {\n  if (builtinExtensions === undefined)\n    return (_defaultResolved ??= [...CORE_EXTENSIONS, ...BUILTIN_EXTENSIONS]);\n  if (builtinExtensions === false) return CORE_EXTENSIONS;\n  return [...CORE_EXTENSIONS, ...builtinExtensions];\n}\n","import type { FromJSOptions } from '../types';\nimport { CBOR_OMIT } from '../types';\nimport type { CborItem } from '../ast/CborItem';\nimport type { CborExtension } from '../extensions/types';\nimport { resolveBuiltinExtensions } from '../extensions/builtins';\nimport { CborUint } from '../ast/CborUint';\nimport { CborNint } from '../ast/CborNint';\nimport { CborBigUint, CborBigNint } from '../ast/CborBignum';\nimport { CborByteString } from '../ast/CborByteString';\nimport { CborTextString } from '../ast/CborTextString';\nimport { CborArray } from '../ast/CborArray';\nimport { CborMap } from '../ast/CborMap';\nimport { CborFloat } from '../ast/CborFloat';\nimport { CborSimple } from '../ast/CborSimple';\nimport { CborTag } from '../ast/CborTag';\nimport { Tag } from '../tag';\nimport { Simple } from '../simple';\nimport { MapEntries } from '../mapEntries';\n\n/**\n * Extension hooks used by _fromJS, pre-filtered so the per-node loops touch\n * only extensions that actually implement each hook.\n */\ninterface ResolvedExtensions {\n  /** Extensions with a fromJS hook (user extensions first). */\n  fromJS: readonly CborExtension[];\n  /** Extensions with a parseTag hook (user extensions first). */\n  parseTag: readonly CborExtension[];\n}\n\n/**\n * Default resolved builtins (no `builtinExtensions` override) pre-filtered\n * per hook, cached after first use. Lazy (not module-level) because\n * mapEntries.ts imports fromJS.ts, forming a cycle that leaves the builtins\n * module's exports undefined at module init time.\n */\nlet _defaultResolvedExts: ResolvedExtensions | undefined;\nfunction getBuiltinResolvedExts(\n  builtinExtensions: CborExtension[] | false | undefined\n): ResolvedExtensions {\n  if (builtinExtensions === undefined) {\n    if (_defaultResolvedExts) return _defaultResolvedExts;\n    const resolved = resolveBuiltinExtensions(undefined);\n    return (_defaultResolvedExts = {\n      fromJS: resolved.filter((ext) => ext.fromJS !== undefined),\n      parseTag: resolved.filter((ext) => ext.parseTag !== undefined),\n    });\n  }\n  const resolved = resolveBuiltinExtensions(builtinExtensions);\n  return {\n    fromJS: resolved.filter((ext) => ext.fromJS !== undefined),\n    parseTag: resolved.filter((ext) => ext.parseTag !== undefined),\n  };\n}\n\n/**\n * Build the hook lists once per fromJS() entry call — _fromJS recursion is\n * per-node, so rebuilding a spread extension array there is measurably slow.\n */\nfunction resolveExtensions(\n  options: FromJSOptions | undefined\n): ResolvedExtensions {\n  const user = options?.extensions;\n  const builtin = getBuiltinResolvedExts(options?.builtinExtensions);\n  if (!user?.length) return builtin;\n  return {\n    fromJS: [\n      ...user.filter((ext) => ext.fromJS !== undefined),\n      ...builtin.fromJS,\n    ],\n    parseTag: [\n      ...user.filter((ext) => ext.parseTag !== undefined),\n      ...builtin.parseTag,\n    ],\n  };\n}\n\n/**\n * Convert a plain JavaScript value to a CborItem AST node.\n *\n * Type dispatch order:\n *   object with [Tag.symbol] symbol       → CborTag (wraps the inner value)\n *   null / undefined / boolean  → CborSimple\n *   bigint                       → CborUint / CborNint / CborBigUint / CborBigNint\n *   number                       → CborFloat, or CborUint/CborNint if integerAs='int' (default)\n *   string                       → CborTextString\n *   Number / Boolean / String / BigInt object → unwrapped primitive (recurse)\n *   Tag.Null / Tag.Undefined              → CborSimple.NULL / UNDEFINED\n *   ArrayBuffer / SharedArrayBuffer            → CborByteString\n *   ArrayBufferView (TypedArray, DataView, …)  → CborByteString (Uint8Array respects uint8ArrayAs)\n *   Array                        → CborArray (recursive)\n *   Map                          → CborMap (keys also converted recursively)\n *   plain object                 → CborMap (string keys → CborTextString)\n */\nexport function fromJS(value: unknown, options?: FromJSOptions): CborItem {\n  if (options?.replacer) {\n    const { replacer, ...rest } = options;\n    const replaced = _applyReplacer(\n      value,\n      replacer,\n      rest.extensions,\n      rest.undefinedOmits,\n      rest.builtinExtensions\n    );\n    if (replaced === CBOR_OMIT) return CborSimple.UNDEFINED;\n    return fromJS(\n      replaced,\n      Object.keys(rest).length > 0 ? (rest as FromJSOptions) : undefined\n    );\n  }\n  return _fromJS(value, options, true, resolveExtensions(options));\n}\n\nfunction _fromJS(\n  value: unknown,\n  options: FromJSOptions | undefined,\n  checkTag: boolean,\n  exts: ResolvedExtensions\n): CborItem {\n  // ── Extension fromJS hooks ───────────────────────────────────────────────────\n  for (const ext of exts.fromJS) {\n    const result = ext.fromJS!(value, options ?? {});\n    if (result !== undefined) return result;\n  }\n\n  // ── CBOR tag annotation (Symbol key) ────────────────────────────────────────\n  // checkTag=false on the recursive call to skip this branch and convert the\n  // inner value normally, avoiding infinite recursion.\n  // After converting the inner value, try parseTag() hooks so that e.g.\n  // dt / ip can produce their specialised subclasses without needing\n  // a separate fromJS() hook on the extension.\n  if (\n    checkTag &&\n    typeof value === 'object' &&\n    value !== null &&\n    Tag.symbol in (value as object)\n  ) {\n    const tag = (value as Record<symbol, bigint>)[Tag.symbol];\n    const innerValue = _fromJS(value, options, false, exts);\n    for (const ext of exts.parseTag) {\n      const result = ext.parseTag!(tag, innerValue);\n      if (result !== undefined) return result;\n    }\n    return new CborTag(tag, innerValue);\n  }\n\n  // ── Null wrapper (from CborTag.toJS() of tagged null) ───────────────────────\n  // Must come AFTER the Tag.symbol check so that Tag.Null (which carries\n  // a [Tag.symbol] symbol) is first wrapped in CborTag, then unwrapped as NULL\n  // in the recursive checkTag=false call.\n  if (value instanceof Tag.Null) return CborSimple.NULL;\n  if (value instanceof Tag.Undefined) return CborSimple.UNDEFINED;\n  if (value instanceof Simple) return new CborSimple(value.value);\n\n  // ── Primitives ───────────────────────────────────────────────────────────────\n  if (value === null) return CborSimple.NULL;\n  if (value === undefined) return CborSimple.UNDEFINED;\n  if (value === true) return CborSimple.TRUE;\n  if (value === false) return CborSimple.FALSE;\n\n  if (typeof value === 'bigint') {\n    if (value > 0xffff_ffff_ffff_ffffn) return new CborBigUint(value);\n    if (value < -(0xffff_ffff_ffff_ffffn + 1n)) return new CborBigNint(value);\n    return value >= 0n ? new CborUint(value) : new CborNint(value);\n  }\n\n  if (typeof value === 'number') {\n    const integerAs = options?.encodeIntegerAs ?? 'int';\n    if (\n      integerAs === 'int' &&\n      Number.isInteger(value) &&\n      !Object.is(value, -0)\n    ) {\n      if (value >= 0) return new CborUint(BigInt(value));\n      return new CborNint(BigInt(value));\n    }\n    return new CborFloat(value);\n  }\n\n  if (typeof value === 'string') return new CborTextString(value);\n\n  // ── Boxed primitives — unwrap and recurse ───────────────────────────────────\n  if (value instanceof Number)\n    return _fromJS(value.valueOf(), options, false, exts);\n  if (value instanceof Boolean)\n    return _fromJS(value.valueOf(), options, false, exts);\n  if (value instanceof String)\n    return _fromJS(value.valueOf(), options, false, exts);\n  // Object(bigint) — detected via Object.prototype.toString\n  if (Object.prototype.toString.call(value) === '[object BigInt]')\n    return _fromJS(\n      (value as { valueOf(): bigint }).valueOf(),\n      options,\n      false,\n      exts\n    );\n\n  // ── ArrayBuffer / SharedArrayBuffer ─────────────────────────────────────────\n  if (\n    value instanceof ArrayBuffer ||\n    (typeof SharedArrayBuffer !== 'undefined' &&\n      value instanceof SharedArrayBuffer)\n  ) {\n    return new CborByteString(new Uint8Array(value as ArrayBuffer));\n  }\n\n  // ── ArrayBufferView (TypedArray variants, DataView) ─────────────────────────\n  if (ArrayBuffer.isView(value)) {\n    if (value instanceof Uint8Array && options?.uint8ArrayAs === 'array') {\n      return new CborArray(Array.from(value, (b) => new CborUint(BigInt(b))));\n    }\n    return new CborByteString(\n      new Uint8Array(value.buffer, value.byteOffset, value.byteLength)\n    );\n  }\n\n  if (value instanceof MapEntries) {\n    return new CborMap(\n      [...value].map(\n        ([k, v]) =>\n          [\n            _fromJS(k, options, true, exts),\n            _fromJS(v, options, true, exts),\n          ] as [CborItem, CborItem]\n      )\n    );\n  }\n\n  if (Array.isArray(value)) {\n    return new CborArray(\n      value.map((item) => _fromJS(item, options, true, exts))\n    );\n  }\n\n  if (typeof value === 'object') {\n    const entries: [CborItem, CborItem][] = [];\n    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {\n      entries.push([new CborTextString(k), _fromJS(v, options, true, exts)]);\n    }\n    return new CborMap(entries);\n  }\n\n  throw new TypeError(`fromJS: unsupported value type: ${typeof value}`);\n}\n\n// ─── Replacer helper ────────────────────────────────────────────────────────\n\ntype _FnReplacer = (this: unknown, key: unknown, value: unknown) => unknown;\ntype _Replacer = _FnReplacer | (string | number)[];\n\n/** True for values that _fromJS handles via a dedicated branch (not Object.entries). */\nfunction _isNativelyHandled(v: object): boolean {\n  return (\n    ArrayBuffer.isView(v) ||\n    v instanceof ArrayBuffer ||\n    (typeof SharedArrayBuffer !== 'undefined' &&\n      v instanceof SharedArrayBuffer) ||\n    v instanceof Number ||\n    v instanceof Boolean ||\n    v instanceof String ||\n    Object.prototype.toString.call(v) === '[object BigInt]' ||\n    v instanceof Tag.Null ||\n    v instanceof Tag.Undefined ||\n    v instanceof Simple\n  );\n}\n\nexport function _applyReplacer(\n  value: unknown,\n  replacer: _Replacer,\n  extensions?: readonly CborExtension[],\n  undefinedOmits?: boolean,\n  builtinExtensions?: CborExtension[] | false\n): unknown {\n  // Only isJSType hooks are consulted below; filter once, not per node.\n  const jsTypeExts: readonly CborExtension[] = [\n    ...(extensions ?? []),\n    ...resolveBuiltinExtensions(builtinExtensions),\n  ].filter((ext) => ext.isJSType !== undefined);\n\n  /** True when a replacer/reviver result should cause the entry to be dropped. */\n  function _omits(v: unknown): boolean {\n    return v === CBOR_OMIT || (undefinedOmits === true && v === undefined);\n  }\n\n  if (Array.isArray(replacer)) {\n    const allowed = (replacer as (string | number)[]).map(String);\n    function filterKeys(v: unknown): unknown {\n      if (v === null || typeof v !== 'object') return v;\n      if (v instanceof MapEntries)\n        return MapEntries.from(\n          v,\n          ([k, val]) => [k, filterKeys(val)] as [unknown, unknown]\n        );\n      if (Array.isArray(v)) return v.map(filterKeys);\n      // Tagged objects pass through so fromJS can encode the tag natively.\n      if (Tag.symbol in (v as object)) return v;\n      // Built-in types pass through so fromJS can handle them natively.\n      if (_isNativelyHandled(v as object)) return v;\n      // Extension-owned values pass through so fromJS can handle them natively.\n      if (jsTypeExts.some((ext) => ext.isJSType!(v))) return v;\n      // Plain objects only: honor toJSON() first (matches JSON.stringify semantics).\n      const proto = Object.getPrototypeOf(v as object) as unknown;\n      if (proto === Object.prototype || proto === null) {\n        const toJSON = (v as Record<string, unknown>)['toJSON'];\n        if (typeof toJSON === 'function')\n          return filterKeys((toJSON as () => unknown).call(v));\n      }\n      const result: Record<string, unknown> = {};\n      for (const k of allowed) {\n        if (Object.prototype.hasOwnProperty.call(v, k))\n          result[k] = filterKeys((v as Record<string, unknown>)[k]);\n      }\n      return result;\n    }\n    return filterKeys(value);\n  }\n\n  const fn = replacer as _FnReplacer;\n  function applyFn(val: unknown, key: unknown, holder: unknown): unknown {\n    // Call toJSON() only on plain objects (proto === Object.prototype or null).\n    // Non-plain objects (Date, TypedArray, extension-backed classes…) pass\n    // through so fromJS extensions can handle them; MapEntries is also skipped\n    // so its integer keys and structure are preserved for CBOR encoding.\n    if (\n      val !== null &&\n      typeof val === 'object' &&\n      !(val instanceof MapEntries)\n    ) {\n      const proto = Object.getPrototypeOf(val as object) as unknown;\n      if (proto === Object.prototype || proto === null) {\n        const toJSON = (val as Record<string, unknown>)['toJSON'];\n        if (typeof toJSON === 'function')\n          val = (toJSON as (k: unknown) => unknown).call(val, key);\n      }\n    }\n    val = fn.call(holder, key, val);\n    if (val !== null && typeof val === 'object') {\n      // Tagged objects pass through so fromJS can encode the tag natively.\n      if (Tag.symbol in (val as object)) return val;\n      if (val instanceof MapEntries) {\n        const result = new MapEntries();\n        for (const [k, v] of val) {\n          const newV = applyFn(v, k, val);\n          if (!_omits(newV)) result.push([k, newV]);\n        }\n        return result;\n      }\n      if (Array.isArray(val)) {\n        return (val as unknown[]).map((v, i) => {\n          const child = applyFn(v, String(i), val);\n          // CBOR.OMIT / undefined-omits in arrays → null (matches JSON.stringify).\n          return _omits(child) ? null : child;\n        });\n      }\n      // Built-in types pass through to fromJS unchanged.\n      if (_isNativelyHandled(val as object)) return val;\n      // Extension-owned values pass through so fromJS can handle them natively.\n      if (jsTypeExts.some((ext) => ext.isJSType!(val))) return val;\n      const result: Record<string, unknown> = {};\n      for (const k of Object.keys(val as object)) {\n        const child = applyFn((val as Record<string, unknown>)[k], k, val);\n        if (!_omits(child)) result[k] = child;\n      }\n      return result;\n    }\n    return val;\n  }\n  return applyFn(value, '', { '': value });\n}\n","import { fromJS } from './js/fromJS';\n\nexport class MapEntries extends Array<[unknown, unknown]> {\n  toJSON(): Record<string, unknown> {\n    const result: Record<string, unknown> = {};\n    for (const [k, v] of this) {\n      const key = typeof k === 'string' ? k : fromJS(k).toCDN();\n      if (key === '__proto__') {\n        Object.defineProperty(result, key, {\n          value: v,\n          writable: true,\n          enumerable: true,\n          configurable: true,\n        });\n      } else {\n        result[key] = v;\n      }\n    }\n    return result;\n  }\n}\n"],"mappings":"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"}