@cbortech/cbor 0.26.8 → 0.27.1

package/dist/ast/CborItem.d.ts

@@ -1,4 +1,4 @@
-import { CBOROptions, ToCDNOptions, ToJSOptions, ToHexDumpOptions, ToCBOROptions, CborComment, CborComments, DecodeWarning, ParseWarning } from '../types';
+import { CBOROptions, ToCDNOptions, ToJSOptions, ToHexDumpOptions, ToCBOROptions, CborComment, CborComments, DecodeWarning, ParseWarning, ItemContext, ReadonlyToJSNodeOptions, CdnItemContext, ReadonlyToCDNOptions } from '../types';
 import { CborWriter } from '../cbor/encode';
 /** @internal One line of an annotated hex dump. */
 export interface AnnotatedLine {
@@ -19,7 +19,7 @@ export interface AppSeqEncodingEdit {
  * Original literal features used by the sole item inside a preserved
  * `prefix<<item>>` source. They let serialization honour an explicitly
  * disabled sibling `preserve*` option instead of replaying that literal
- * verbatim through `preserveAppSequence`.
+ * verbatim through `preserveAppPrefix`.
  */
 export interface AppSeqSourceFeatures {
     byteString?: boolean;
@@ -27,6 +27,194 @@ export interface AppSeqSourceFeatures {
     rawString?: boolean;
     concatenation?: boolean;
 }
+/**
+ * @internal
+ * Cheap upfront check for whether per-node option/extension resolution is
+ * needed at all for a given `toJS()` options object. Container nodes use
+ * this to choose between the plain `child._toJS(options)` recursion (when
+ * `false`, identical cost to before `itemOptions`/`extensions` existed) and
+ * `child._toJSChild(options, path, ctx)` (when `true`).
+ */
+export declare function needsItemDispatch(options: ToJSOptions | undefined): boolean;
+/**
+ * @internal
+ * Options for a reviver-driven container's "raw" structural pre-population
+ * pass (see `CborArray`/`CborMap.toObject`) — `reviver` removed, everything
+ * else (including `itemOptions`/`extensions`) left as-is.
+ *
+ * This pass's output is never returned to the caller as the final result —
+ * every position it computes is unconditionally overwritten by the *real*
+ * (revived) pass's own result before `toJS()` returns — but it is not
+ * write-only scaffolding either: a `reviver` reads it directly, as `this[j]`
+ * for a not-yet-processed sibling `j`, while deciding how to revive an
+ * *earlier* sibling (matching `JSON.parse`'s own reviver contract, which
+ * this replicates). That value must reflect `itemOptions`/`extensions`
+ * exactly as the real pass would — e.g. an `integerAs: 'bigint'` override
+ * for position `j` — or a reviver reading `this[j]` would see the wrong
+ * type. So `itemOptions`/`extensions` stay active here, unlike `reviver`
+ * itself.
+ *
+ * Running dispatch during this pass is safe only because callers building
+ * a child's occurrence for it — `CborArray`/`CborMap.toObject` — insert
+ * `RAW_PASS_MARKER` into that occurrence (see `Occurrence`), so its
+ * resolutions are filed under a different `DispatchCache` key than the
+ * real pass's and can never be reused *by* the real pass, however many
+ * ancestor levels apart the two passes are. That distinction matters for
+ * more than consistency — a composite (non-scalar) map key is itself
+ * revived differently between the two passes (this pass leaves its own
+ * nested content entirely unrevived, matching `this[j]`'s contract above;
+ * the real pass revives it normally), so a value node whose
+ * `ItemContext.path` is built from that key's converted JS value would
+ * otherwise see a stale, pre-revival path if the real pass reused this
+ * pass's cached decision.
+ */
+export declare function withoutReviver(options: ToJSOptions | undefined): ToJSOptions | undefined;
+/**
+ * @internal
+ * Build the `reviver`-free, `extensions`-copied view of `options` handed
+ * to code that must not be able to mutate options actually in effect
+ * elsewhere in the tree — `ItemContext.options` and the `options`
+ * parameter of `CborExtension.toJS()` — see `ReadonlyToJSNodeOptions`.
+ *
+ * A plain `{ ...options, reviver: undefined }` spread (as `withoutReviver`
+ * does) is not enough here: `extensions`, if present, would still be the
+ * *same array* `options.extensions` is, so `.push()`/`.splice()`/etc. on
+ * the copy would still mutate the original in place — corrupting it for
+ * this node's own later use, its siblings, and the caller. `extensions` is
+ * the only field on `ToJSOptions` that's an ordinary mutable container, so
+ * it's the only one that needs its own copy here.
+ */
+export declare function toReadonlyNodeOptions(options: ToJSOptions): ReadonlyToJSNodeOptions;
+/**
+ * @internal
+ * Stable, allocation-light identifier for "this occurrence of a node" —
+ * used only to key `DispatchCache` lookups, never exposed via
+ * `ItemContext`. Built exactly the way `ItemContext.path` is (accumulated
+ * from the root, one element per container level, unchanged through a
+ * tag/app-sequence wrapper), but from *structural* container positions —
+ * an array index, or a map entry's ordinal paired with a `'k'`/`'v'` role
+ * tag (see `CborArray`/`CborMap`) — rather than from the JS values `path`
+ * is built from.
+ *
+ * That distinction matters in two ways `path` alone (or even `path` plus
+ * only the *immediate* container's identity) does not cover:
+ *
+ * - A composite (non-scalar) map key re-converts to a *new* array/object
+ *   every time its JS value is asked for, so two visits to the very same
+ *   logical position produce `path`s that are structurally equal but not
+ *   reference-equal at that segment — unusable for matching.
+ * - Two different positions can legitimately produce the very same `path`,
+ *   when duplicate map entries carry equal keys (e.g. two `"a"` entries).
+ * - A *container* (not just a leaf) can itself be a shared node instance
+ *   reused at two positions (e.g. the same `CborArray` placed at two
+ *   different indices of an outer array). Matching only on `{immediate
+ *   parent identity, local slot}` — as an earlier version of this type
+ *   did — correctly distinguishes the *container's own* two occurrences,
+ *   but not its *descendants'*: each of the shared container's children
+ *   would resolve `{parent: <the shared container>, slot: <local index>}`
+ *   identically regardless of which of the container's own two
+ *   occurrences was being converted, silently conflating them. Chaining
+ *   the full occurrence from the root — rather than just one level —
+ *   avoids this: the shared container's own two occurrences differ
+ *   earlier in the chain, so appending the same local slot to each still
+ *   yields two different full chains for its children.
+ *
+ * A local slot only needs to be unique among its own container's direct
+ * children — `CborArray` uses the element index (`number`) directly;
+ * `CborMap` prefixes a map entry's ordinal with `'k'`/`'v'`
+ * (`` `k${i}` ``/`` `v${i}` ``) so a key and its own value, which share an
+ * ordinal, don't collide.
+ *
+ * `RAW_PASS_MARKER` (see below) is the one non-structural element this
+ * chain can contain: `CborArray`/`CborMap.toObject` insert it — once,
+ * immediately before that level's own local slot — only when building a
+ * child's occurrence for their raw structural pre-population pass (see
+ * `withoutReviver`), never for the real, revived pass. That's what lets
+ * `_toJSChild`'s cache correctly tell apart the *distinct* raw-pass
+ * resolutions a single occurrence can otherwise receive when more than one
+ * ancestor level forks — e.g. the very same value node visited once
+ * through an outer container's own raw pass (before *any* ancestor has
+ * revived anything) and once more through a different, inner container's
+ * own raw pass nested inside the outer's real pass (after some ancestor,
+ * such as a composite map key, *has* already been revived) — two visits
+ * that share every structural coordinate yet must not share a cached
+ * decision, since what a reviver-sensitive value like that key converts to
+ * differs between them (see `DispatchCacheEntry`). A container that isn't
+ * itself forking (no `reviver` in its own options, so it takes the plain,
+ * unsplit path) never inserts the marker — it simply passes the
+ * occurrence chain it was given through unchanged before extending it with
+ * its own children's local slots, the same way it always did.
+ */
+export type Occurrence = readonly unknown[];
+/**
+ * @internal
+ * Sentinel inserted into an `Occurrence` chain by `CborArray`/
+ * `CborMap.toObject` when building a child's occurrence for their own raw
+ * structural pre-population pass — see `Occurrence`'s own note. A
+ * dedicated symbol rather than a string/number so it can never collide
+ * with an ordinary local slot value (an array index or a `` `k${i}` ``/
+ * `` `v${i}` `` map-entry tag).
+ */
+export declare const RAW_PASS_MARKER: unique symbol;
+/**
+ * @internal
+ * The root value's occurrence, for `toJS()`'s own top-level `_toJSChild()`
+ * call — empty, the same way `ItemContext.path` is empty at the root. Also
+ * used by `CborTag`/`CborAppSeqResult` as a defensive fallback if `_toJS()`
+ * is ever invoked without an `occurrence` (only possible via a direct,
+ * non-`toJS()` call to `_toJS()`, which the dispatch cache never sees).
+ */
+export declare const ROOT_OCCURRENCE: Occurrence;
+/**
+ * @internal
+ * Cheap upfront check for whether per-node option resolution is needed at
+ * all for a given `toCDN()` options object — the `toCDN()` analogue of
+ * `needsItemDispatch`.
+ */
+export declare function needsCdnItemDispatch(options: ToCDNOptions | undefined): boolean;
+/**
+ * @internal
+ * Build the copied-`textStringFormat` view of `options` handed to
+ * `CdnItemContext.options` — the `toCDN()` analogue of
+ * `toReadonlyNodeOptions`; see `ReadonlyToCDNOptions`. Also strips
+ * `CDN_OVERRIDE_TRACKER` (see there) — `ctx.options` is documented as
+ * reflecting the current *effective options*, so it should never expose an
+ * internal, out-of-band bookkeeping key that isn't part of `ToCDNOptions` at
+ * all, even though it isn't otherwise observable through any named field.
+ */
+export declare function toReadonlyCdnOptions(options: ToCDNOptions): ReadonlyToCDNOptions;
+/**
+ * @internal
+ * Out-of-band symbol key that lets a caller (currently only
+ * `CborAppSeqResult._toCDN`) track, across an entire `_resolveCdnOptions()`
+ * subtree, whether `itemOptions` ever actually returned an override —
+ * without touching `options.itemOptions` itself.
+ *
+ * `CborAppSeqResult` needs to know whether its preserved verbatim source is
+ * still exactly right after offering `itemOptions` a chance to override one
+ * of its descendants (see its own doc). Wrapping `options.itemOptions` in a
+ * tracking function was tried first, but that function becomes
+ * `ctx.options.itemOptions` for every descendant (`_resolveCdnOptions`
+ * builds `ctx.options` from the very `options` it was given) — a pure
+ * `itemOptions` callback could tell it apart from the caller's own function
+ * by identity, observing a difference between an ordinary subtree and one
+ * reached through an app-sequence wrapper that `ctx.options`'s "current
+ * effective options" contract never promises.
+ *
+ * A symbol-keyed property on `options` instead survives every
+ * `{...options, ...override}` merge `_resolveCdnOptions` performs exactly
+ * the same way `itemOptions` itself does (object spread copies symbol keys
+ * too, and by reference — the same tracker box is shared, never cloned, by
+ * every node in the subtree), while never being part of the public
+ * `ToCDNOptions` shape or observable through any named field — see
+ * `toReadonlyCdnOptions`, which explicitly strips it before building
+ * `ctx.options`.
+ */
+export declare const CDN_OVERRIDE_TRACKER: unique symbol;
+/** @internal Mutable box referenced (never copied) via `CDN_OVERRIDE_TRACKER`. */
+export interface CdnOverrideTrackerBox {
+    applied: boolean;
+}
 /**
  * Abstract base class for all CBOR AST nodes.
  *
@@ -63,11 +251,11 @@ export declare abstract class CborItem {
      */
     blankLineBefore?: boolean;
     /**
-     * Original application-string/-sequence source text — `prefix'...'`,
+     * Original app-string/-sequence source text — `prefix'...'`,
      * `` prefix`...` ``, or `prefix<<...>>` — set by the parser when the
      * resolving extension declares `preserveAppSeqSource: 'optional'`. A
      * subclass's own `_toCDN()` override may check this (gated behind
-     * `ToCDNOptions.preserveAppSequence`) to round-trip the exact original
+     * `ToCDNOptions.preserveAppPrefix`) to round-trip the exact original
      * spelling instead of always regenerating `prefix'...'` notation from the
      * resolved value. Left `undefined` for nodes not parsed from one of these
      * forms.
@@ -77,7 +265,7 @@ export declare abstract class CborItem {
      * Comments contained within `appSeqSource`, with `start`/`end` offsets
      * relative to that string. These spans allow comment markers to be
      * converted (or comments to be removed) without regenerating and thereby
-     * losing the original application-string/-sequence notation.
+     * losing the original app-string/-sequence notation.
      */
     appSeqComments?: CborComment[];
     /**
@@ -140,6 +328,57 @@ export declare abstract class CborItem {
      * `_toCDN()`, which omits `entryIsLeaf` for that reason.
      */
     get _containsCdnContainer(): boolean;
+    /**
+     * @internal
+     * True when this node's own text content (a text string, or a byte
+     * string that would render as bare sqstr text) has two or more words —
+     * `inlineLeafContainers` never collapses a container whose entries hold
+     * such a string onto the container's own line, even though the entry
+     * itself has no nested array/map, since a multi-word string reads better
+     * with room of its own. See `isMultiWordText()`/`isMultiWordByteString()`
+     * in `cdn/serialize-utils.ts`. Takes `options` because whether a byte
+     * string even renders as text (`'...'`) rather than a prefixed literal
+     * (`h'...'`, `b64'...'`, ...) depends on the `sqstr` option.
+     *
+     * This method deliberately does *not* also cover the "is this (or does
+     * it wrap) a prefixed literal" question — a prefixed literal has no word
+     * count to check, but still disqualifies under the strict rule (and, per
+     * `strict`, is an ordinary leaf under the loose one). That's handled
+     * generically elsewhere instead, from the *actual rendered text* rather
+     * than predicted from this node's type: `isPrefixedLiteralText` for a
+     * bare entry (`serializeContainer` checks it against the already
+     * rendered `s`), or `isMultiWordRenderedLiteral` for `CborTag`, which
+     * overrides this method entirely to tokenize its own `_toCDN()` output
+     * instead of delegating here — necessary because a `CborTag` subclass
+     * (`CborTaggedIpExt`, `CborTaggedEpochDtExt`, ...) may override `_toCDN()`
+     * to render something that doesn't look like generic `tagNum(content)`
+     * notation at all, which a semantic prediction from `this.content` alone
+     * could never know about.
+     *
+     * `strict` (default `true`) is passed down by whichever container's own
+     * `_toCDN` directly holds this entry: `true` for the strict rule
+     * (`CborArray`/`CborMap`, and `CborIndefiniteTextString`/
+     * `CborIndefiniteByteString` too — all four provide `entryIsLeaf`),
+     * `false` only for `CborEmbeddedCBOR` (`<<...>>`), the one container
+     * whose collapse isn't gated behind `inlineLeafContainers` at all and
+     * the only one that omits `entryIsLeaf`. This base implementation and
+     * `CborTextString`/`CborByteString`'s overrides ignore `strict` (a text
+     * string's, or byte string's own sqstr-text, word count is unaffected by
+     * it either way) — only `CborTag` (and, transitively, `CborAppSeqResult`
+     * delegating to its inner value) actually consult it.
+     *
+     * `path` is this entry's own full path (see `CdnItemContext.path`),
+     * passed down by the same caller for the same reason `renderEntry`
+     * receives it: `CborTag`/`CborAppSeqResult` re-render `this` here (see
+     * their own overrides) purely to answer this method's question, and that
+     * re-render must resolve any of *its own* descendants' `itemOptions`
+     * against the entry's real path — not an empty one — or a descendant
+     * several levels inside a tag-wrapped entry could see a different
+     * `ctx.path` here than the real render further down gives it. Only
+     * `CborTag`/`CborAppSeqResult` consult it; every other override ignores
+     * it, the same as `strict`.
+     */
+    _isMultiWordText(_options: ToCDNOptions | undefined, _strict?: boolean, _path?: readonly unknown[]): boolean;
     /** Serialize this node to CBOR binary. */
     toCBOR(options?: ToCBOROptions): Uint8Array;
     /** Serialize this node to a CDN text string. */
@@ -206,17 +445,108 @@ export declare abstract class CborItem {
      * @internal
      * Depth-aware CDN serialization.
      * Leaf nodes receive `depth` but may ignore it.
-     * Container nodes use `depth` for indentation and call
-     * `child._toCDN(options, depth + 1)` when recursing.
+     * Container nodes use `depth` for indentation and, when recursing, must
+     * resolve each child's options via `child._resolveCdnOptions()` first
+     * (rather than passing `options` straight through) so `itemOptions` is
+     * honored for every node, not just the root — see `_resolveCdnOptions`.
+     * `path` is this node's own full path from the root (see
+     * `CdnItemContext.path`); only meaningful when `needsCdnItemDispatch()`
+     * is `true` for the options in effect — leaf implementations that don't
+     * recurse can ignore it, as can any implementation when dispatch isn't
+     * in play.
      */
-    abstract _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    abstract _toCDN(options: ToCDNOptions | undefined, depth: number, path?: readonly unknown[]): string;
+    /**
+     * @internal
+     * Resolve `options.itemOptions` for this node (if any), returning the
+     * options a caller should use for both this node's own `_toCDN()` call
+     * and (via `_isMultiWordText()`) any layout probe of it — see
+     * `CdnItemContext`. Unlike `toJS()`'s `_toJSChild()`, this never caches:
+     * see the "toCDN() per-item dispatch" note above `needsCdnItemDispatch`
+     * for why that's both unnecessary and, per this codebase's own prior
+     * experience with `CborTag._isMultiWordText`, unsafe here specifically.
+     *
+     * `ctx` follows the same "no `key`, derived from `path`'s last element"
+     * convention `_toJSChild()` uses (see there) — a caller passes
+     * `parent`/`keyNode`/`isMapKey` only; `key` is filled in here.
+     */
+    _resolveCdnOptions(options: ToCDNOptions | undefined, path: readonly unknown[], ctx: Omit<CdnItemContext, 'path' | 'key' | 'options'>): ToCDNOptions | undefined;
     /**
      * @internal
      * Core conversion logic implemented by each subclass.
-     * Container nodes apply `options.reviver` to their direct children.
+     * Container nodes apply `options.reviver` to their direct children, and
+     * must recurse via `child._toJSChild()` (never `child._toJS()` directly)
+     * so that `options.itemOptions`/`options.extensions` are honored for
+     * every node, not just the root — see `_toJSChild`.
+     * `path` is this node's own full path from the root (see `ItemContext.path`);
+     * only meaningful, and only ever non-empty, when `needsItemDispatch()` is
+     * `true` for the options in effect — leaf implementations that don't
+     * recurse can ignore it. `occurrence` is this node's own cache-matching
+     * identity (see `Occurrence`) — `CborArray`/`CborMap` build on it to
+     * derive their children's own occurrences, and `CborTag`/`CborAppSeqResult`
+     * pass it through unchanged to their content's `_toJSChild()` call; leaf
+     * implementations that don't recurse can ignore it.
      * Do not call this directly — use `toJS()` instead.
      */
-    abstract _toJS(options?: ToJSOptions): unknown;
+    abstract _toJS(options?: ToJSOptions, path?: readonly unknown[], occurrence?: Occurrence): unknown;
+    /**
+     * @internal
+     * Entry point container nodes must use when recursing into a child during
+     * `toJS()`, instead of calling `child._toJS(options)` directly, so that
+     * `options.itemOptions` and `options.extensions` (toJS hooks) are honored
+     * for every node in the tree, not just the root.
+     *
+     * Guarded by `needsItemDispatch()` at each call site rather than
+     * internally, so that containers can skip straight to the cheap
+     * `child._toJS(options)` call — matching pre-`itemOptions` behavior
+     * exactly, with no extra allocation — whenever neither option is in play
+     * for the whole conversion.
+     *
+     * `path` is this child's own full path from the root, already computed by
+     * the caller: `[...parentPath, key]` for an array element or map
+     * entry/key, or the parent's own `path` unchanged for a transparent
+     * wrapper's content (`CborTag`, `CborAppSeqResult`) — see
+     * `ItemContext.path`. `ctx.key` is *not* supplied by the caller — it's
+     * derived here from `path`'s own last element (or left `undefined` for
+     * the root and for `isMapKey` visits), which is what keeps a wrapper's
+     * content correctly reporting its outer key: since `CborTag`/
+     * `CborAppSeqResult` pass their own unmodified `path` straight through,
+     * that derivation naturally recovers the tag's own key for its content
+     * too, matching `ItemContext.key`'s documented invariant of always
+     * equalling `path`'s last element outside those two exceptions.
+     *
+     * `occurrence` identifies this child's position for cache-matching
+     * purposes only (see `Occurrence`) — deliberately separate from `path`,
+     * which is built from *converted JS values* and so is unreliable for
+     * that: matching on `path` alone either double-resolves the same position
+     * (a composite map key converts to a fresh, non-`===` array/object every
+     * time) or wrongly conflates two different positions that happen to
+     * convert to equal `path`s (duplicate map entries with equal keys).
+     * `occurrence` avoids both by construction — see `Occurrence`.
+     *
+     * A single node can be visited more than once *at the same occurrence* in
+     * one `toJS()` call — a `reviver`-driven `CborArray`/`CborMap` converts
+     * each child once to pre-populate an unrevived holder and once more to
+     * compute the revived value (see their own `_toJS()`), and either pass
+     * may itself recurse through a `CborTag`/`CborAppSeqResult` wrapper that
+     * adds no occurrence of its own (content shares the wrapper's). The raw
+     * pre-population pass's own occurrence for a child is distinguished from
+     * the real pass's by `RAW_PASS_MARKER` (see `Occurrence`), so that even
+     * distinct, *nested* raw passes reaching the same node — one from an
+     * outer container's own split, one from a different, inner container's
+     * own split nested inside the outer's real pass — resolve independently
+     * rather than colliding with each other. Neither `options.itemOptions`
+     * nor an `extensions` `toJS()` hook may run more than once for the same
+     * occurrence despite all that, since either may be stateful — so the
+     * *decision* (not the reviver-dependent application of an `itemOptions`
+     * override — see `DispatchOutcome`) is cached in `options`'s dispatch
+     * cache, when one is present, and reused on a later visit to that exact
+     * occurrence. A node *reused* at more than one occurrence (the same
+     * `CborItem` instance placed at two positions in a hand-built tree)
+     * still resolves once per occurrence, never conflating two different
+     * ones.
+     */
+    _toJSChild(options: ToJSOptions | undefined, path: readonly unknown[], occurrence: Occurrence, ctx: Omit<ItemContext, 'path' | 'key' | 'options'>): unknown;
     /**
      * @internal
      * Collect annotated-hex lines for this node.

package/dist/ast/CborMap.d.ts

@@ -12,7 +12,7 @@ export declare class CborMap extends CborItem {
     });
     get _containsCdnContainer(): boolean;
     _encodeTo(writer: CborWriter, options?: ToCBOROptions): void;
-    _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, depth: number, path?: readonly unknown[]): string;
     _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[];
-    _toJS(options?: ToJSOptions): unknown;
+    _toJS(options?: ToJSOptions, path?: readonly unknown[], occurrence?: readonly unknown[]): unknown;
 }

package/dist/ast/CborNint.d.ts

@@ -31,6 +31,6 @@ export declare class CborNint extends CborItem {
     /** The actual decoded negative value (−1 − argument). */
     get value(): bigint;
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;
-    _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, _depth: number, _path?: readonly unknown[]): string;
     _toJS(options?: ToJSOptions): unknown;
 }

package/dist/ast/CborTag.d.ts

@@ -1,5 +1,5 @@
 import { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';
-import { CborItem, AnnotatedLine } from './CborItem';
+import { CborItem, AnnotatedLine, Occurrence } from './CborItem';
 import { CborWriter, EncodingWidth } from '../cbor/encode';
 /** CBOR Major Type 6 — tagged data item. */
 export declare class CborTag extends CborItem {
@@ -18,8 +18,35 @@ export declare class CborTag extends CborItem {
         ednSource?: string;
     });
     get _containsCdnContainer(): boolean;
+    /**
+     * Checked by tokenizing `this._toCDN()`'s own actual output — not by
+     * delegating to `this.content._isMultiWordText()` (a semantic prediction
+     * from the AST) — because a subclass may override `_toCDN()` to render
+     * something that doesn't match generic `tagNum(content)` notation at all
+     * (`CborTaggedIpExt` renders `IP<<'192.0.2.42'>>`, `CborTaggedEpochDtExt`
+     * renders `DT'...'`/`DT<<...>>`, ...); a check based on `this.content`
+     * would be looking at the wrong thing entirely for those. Tokenizing the
+     * real output instead is exact regardless of which class produced it —
+     * see `isMultiWordRenderedLiteral`, which also handles the plain,
+     * generic-tag case (peeling `tagNum[_EI](...)` to see what's inside, so
+     * `100(dt'...')` and `100("two words")` still work the same as before).
+     *
+     * Deliberately *not* cached: an earlier version cached this render on
+     * the instance keyed by `options` reference alone, which was wrong two
+     * ways — (1) `preserveConcatenation`'s continuation-line indentation
+     * *does* depend on depth even for leaf content, so a render cached at
+     * depth 0 here and reused by `_toCDN`'s real render at a different depth
+     * produced under-indented continuation lines; (2) the cache persisted
+     * on the node forever and was keyed only by object identity, so
+     * mutating the same `options` object between two `toCDN()` calls
+     * silently returned the first call's stale result. `this` is re-rendered
+     * here and again by the real `_toCDN` call from whatever holds this
+     * entry — an accepted, narrow cost (only tag-wrapped entries reach this
+     * at all).
+     */
+    _isMultiWordText(options: ToCDNOptions | undefined, strict?: boolean, path?: readonly unknown[]): boolean;
     _encodeTo(writer: CborWriter, options?: ToCBOROptions): void;
-    _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, depth: number, path?: readonly unknown[]): string;
     _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[];
-    _toJS(options?: ToJSOptions): unknown;
+    _toJS(options?: ToJSOptions, path?: readonly unknown[], occurrence?: Occurrence): unknown;
 }

package/dist/ast/CborTextString.d.ts

@@ -25,7 +25,7 @@ export declare class CborTextString extends CborItem {
     /**
      * `true` at index `i`, aligned with `ednParts`, when that part came from a
      * byte-string literal on the right of a text-leading `+` concatenation
-     * (decoded as UTF-8 and merged in per §5.1) rather than a double-quoted
+     * (decoded as UTF-8 and merged in per draft-25 §5.1) rather than a double-quoted
      * `"..."` literal. Both cases leave `ednPartSources[i]` `undefined` (byte
      * strings have no preserved raw source here, same as an unpreserved
      * double-quoted literal), so this is what lets `appSeqSourceFeatures`
@@ -57,7 +57,8 @@ export declare class CborTextString extends CborItem {
             end: number;
         }[];
     });
+    _isMultiWordText(_options: ToCDNOptions | undefined, _strict?: boolean, _path?: readonly unknown[]): boolean;
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;
-    _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, depth: number, _path?: readonly unknown[]): string;
     _toJS(_options?: ToJSOptions): unknown;
 }

package/dist/ast/CborUint.d.ts

@@ -17,6 +17,6 @@ export declare class CborUint extends CborItem {
         ednSource?: string;
     });
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;
-    _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, _depth: number, _path?: readonly unknown[]): string;
     _toJS(options?: ToJSOptions): unknown;
 }

package/dist/ast/CborUnresolvedAppExt.d.ts

@@ -1,10 +1,10 @@
 import { ToCDNOptions } from '../types';
 import { CborTag } from './CborTag';
 import { CborItem } from './CborItem';
-/** Provisional tag number for the Unresolved Application-Extension stand-in. */
+/** Provisional tag number for the Unresolved App-Extension stand-in. */
 export declare const CPA999_TAG = 999n;
 /**
- * Stand-in for an unrecognised EDN application-extension literal.
+ * Stand-in for an unrecognised EDN app-extension literal.
  *
  * Structure:
  *   App-string:  CPA999([prefix, text])

package/dist/ast/index.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../mapEntries-BJzyBUH5.cjs");exports.CborArray=e.D,exports.CborBigNint=e._,exports.CborBigUint=e.v,exports.CborByteString=e.A,exports.CborEmbeddedCBOR=e.w,exports.CborFloat=e.M,exports.CborIndefiniteByteString=e.k,exports.CborIndefiniteTextString=e.O,exports.CborItem=e.I,exports.CborMap=e.E,exports.CborNint=e.P,exports.CborSimple=e.T,exports.CborTag=e.j,exports.CborTextString=e.h,exports.CborUint=e.F;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../mapEntries-CZZJScaj.cjs");exports.CborArray=e.E,exports.CborBigNint=e._,exports.CborBigUint=e.v,exports.CborByteString=e.k,exports.CborEmbeddedCBOR=e.C,exports.CborFloat=e.j,exports.CborIndefiniteByteString=e.O,exports.CborIndefiniteTextString=e.D,exports.CborItem=e.F,exports.CborMap=e.T,exports.CborNint=e.N,exports.CborSimple=e.w,exports.CborTag=e.A,exports.CborTextString=e.h,exports.CborUint=e.P;

package/dist/ast/index.js

@@ -1,2 +1,2 @@
-import { A as e, D as t, E as n, F as r, I as i, M as a, O as o, P as s, T as c, _ as l, h as u, j as d, k as f, v as p, w as m } from "../mapEntries-Ci_dppP6.js";
-export { t as CborArray, l as CborBigNint, p as CborBigUint, e as CborByteString, m as CborEmbeddedCBOR, a as CborFloat, f as CborIndefiniteByteString, o as CborIndefiniteTextString, i as CborItem, n as CborMap, s as CborNint, c as CborSimple, d as CborTag, u as CborTextString, r as CborUint };
+import { A as e, C as t, D as n, E as r, F as i, N as a, O as o, P as s, T as c, _ as l, h as u, j as d, k as f, v as p, w as m } from "../mapEntries-CCLaJSaJ.js";
+export { r as CborArray, l as CborBigNint, p as CborBigUint, f as CborByteString, t as CborEmbeddedCBOR, d as CborFloat, o as CborIndefiniteByteString, n as CborIndefiniteTextString, i as CborItem, c as CborMap, a as CborNint, m as CborSimple, e as CborTag, u as CborTextString, s as CborUint };

package/dist/cddl/index.cjs

@@ -1,3 +1,3 @@
-Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("../schema-DgnkH0P6.cjs");function t(e,t){let n=Math.max(0,Math.min(t,e.length)),r=1,i=0;for(let t=0;t<n;t++)e.charCodeAt(t)===10&&(r++,i=t+1);return{line:r,column:n-i+1}}var n=class{static compile(t,n){return e.n(t,n)}};function r(t){let n=new e.o(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function i(t){let n=new e.o(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.l?i:new e.l(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("../schema-zsg5yCPK.cjs");function t(e,t){let n=Math.max(0,Math.min(t,e.length)),r=1,i=0;for(let t=0;t<n;t++)e.charCodeAt(t)===10&&(r++,i=t+1);return{line:r,column:n-i+1}}var n=class{static compile(t,n){return e.n(t,n)}};function r(t){let n=new e.o(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function i(t){let n=new e.o(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.l?i:new e.l(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
 `?(e++,n=1):n++;r.push({type:`ERROR`,value:t.slice(o),raw:t.slice(o),line:e,col:n,offset:o,endOffset:t.length})}return{tokens:r,comments:n.comments,error:a}}}exports.CDDL=n,exports.default=n,exports.CddlMismatchError=e.s,exports.CddlSchema=e.t,exports.CddlSemanticError=e.c,exports.CddlSyntaxError=e.l,exports.PRELUDE_CDDL=e.r,exports.getPreludeRules=e.i,exports.parseCDDL=e.a,exports.positionAt=t,exports.tokenize=r,exports.tokenizeLenient=i;
 //# sourceMappingURL=index.cjs.map

package/dist/cddl/index.js

@@ -1,4 +1,4 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "../schema-y8G5mDIS.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "../schema-DN9inJny.js";
 //#region src/cddl/position.ts
 function l(e, t) {
 	let n = Math.max(0, Math.min(t, e.length)), r = 1, i = 0;

package/dist/cdn/index.cjs

@@ -1,3 +1,3 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../tokenizer-BD08xbyd.cjs");function t(t){let n=new e.t(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function n(t){let n=new e.t(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.D?i:new e.D(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
-`?(e++,n=1):n++;r.push({type:`ERROR`,value:t.slice(o),raw:t.slice(o),line:e,col:n,offset:o,endOffset:t.length})}return{tokens:r,comments:n.comments,error:a}}}exports.CdnSyntaxError=e.D,exports.adjustAppSeqIndicator=e.n,exports.adjustRawAppSeqSource=e.r,exports.canonicalEncodingWidth=e.i,exports.decideTaggedAppSeqRendering=e.s,exports.resolveEiSuffix=e._,exports.tokenize=t,exports.tokenizeLenient=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../serialize-utils-DhlW61ZX.cjs");function t(t){let n=new e.A(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function n(t){let n=new e.A(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.I?i:new e.I(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
+`?(e++,n=1):n++;r.push({type:`ERROR`,value:t.slice(o),raw:t.slice(o),line:e,col:n,offset:o,endOffset:t.length})}return{tokens:r,comments:n.comments,error:a}}}exports.CdnSyntaxError=e.I,exports.adjustAppSeqIndicator=e.t,exports.adjustRawAppSeqSource=e.n,exports.canonicalEncodingWidth=e.r,exports.decideTaggedAppSeqRendering=e.o,exports.resolveEiSuffix=e.C,exports.tokenize=t,exports.tokenizeLenient=n;
 //# sourceMappingURL=index.cjs.map

package/dist/cdn/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/cdn/index.ts"],"sourcesContent":["/**\n * Public lower-level CDN tokenization and serialization API\n * (`@cbortech/cbor/cdn`).\n *\n * Exposes the same lexer the parser uses, so tooling such as syntax\n * highlighters stays in exact agreement with parsing behavior. Also exposes\n * the `preserveAppSequence` source-preservation primitives that the built-in\n * `dt`/`ip`/`cri` extensions use, so a third-party `CborExtension` whose\n * result has its own dedicated notation (regenerated from a resolved value,\n * the way `dt'...'`/`ip'...'`/`cri'...'` do) can support `preserveAppSequence`\n * too, instead of always discarding the original `` prefix`...` ``,\n * non-canonical `prefix'...'`, or raw-tag `N(...)` source spelling. See the\n * `dt`/`ip`/`cri` extension sources for the pattern these are meant to be\n * used in.\n */\n\nimport { Tokenizer, type Token, type EdnComment } from './tokenizer';\nimport { CdnSyntaxError } from './errors';\n\nexport type { Token, TokenType, EdnComment } from './tokenizer';\nexport { CdnSyntaxError } from './errors';\n\nexport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n  decideTaggedAppSeqRendering,\n  adjustRawAppSeqSource,\n  adjustAppSeqIndicator,\n} from './serialize-utils';\nexport type { AppSeqRenderDecision } from './serialize-utils';\n\nexport interface TokenizeResult {\n  /** Scanned tokens in source order, excluding the final EOF token. */\n  tokens: Token[];\n  /** Comments encountered while scanning, in source order. */\n  comments: EdnComment[];\n}\n\nexport interface TokenizeLenientResult extends TokenizeResult {\n  /**\n   * The scan failure, if any. When set, `tokens` ends with a synthetic\n   * `ERROR` token covering the source from the last clean token to the end\n   * of the input.\n   */\n  error?: CdnSyntaxError;\n}\n\n/**\n * Tokenize CDN text. Throws {@link CdnSyntaxError} on invalid input.\n */\nexport function tokenize(text: string): TokenizeResult {\n  const tokenizer = new Tokenizer(text);\n  const tokens: Token[] = [];\n  for (;;) {\n    const tok = tokenizer.consume();\n    if (tok.type === 'EOF') break;\n    tokens.push(tok);\n  }\n  return { tokens, comments: tokenizer.comments };\n}\n\n/**\n * Error-tolerant tokenization for editors and highlighters: never throws on\n * invalid input. Tokens before the failure are returned as scanned; the\n * remainder of the input is covered by a single synthetic `ERROR` token and\n * the failure is reported in `error`.\n */\nexport function tokenizeLenient(text: string): TokenizeLenientResult {\n  const tokenizer = new Tokenizer(text);\n  const tokens: Token[] = [];\n  try {\n    for (;;) {\n      const tok = tokenizer.consume();\n      if (tok.type === 'EOF') break;\n      tokens.push(tok);\n    }\n    return { tokens, comments: tokenizer.comments };\n  } catch (e) {\n    const error =\n      e instanceof CdnSyntaxError\n        ? e\n        : new CdnSyntaxError(e instanceof Error ? e.message : String(e));\n    const start = tokenizer.lastEndOffset;\n    if (start < text.length) {\n      let line = 1;\n      let col = 1;\n      for (let i = 0; i < start; i++) {\n        if (text[i] === '\\n') {\n          line++;\n          col = 1;\n        } else {\n          col++;\n        }\n      }\n      tokens.push({\n        type: 'ERROR',\n        value: text.slice(start),\n        raw: text.slice(start),\n        line,\n        col,\n        offset: start,\n        endOffset: text.length,\n      });\n    }\n    return { tokens, comments: tokenizer.comments, error };\n  }\n}\n"],"mappings":"gHAkDA,SAAgB,EAAS,EAA8B,CACrD,IAAM,EAAY,IAAI,EAAA,EAAU,CAAI,EAC9B,EAAkB,CAAC,EACzB,OAAS,CACP,IAAM,EAAM,EAAU,QAAQ,EAC9B,GAAI,EAAI,OAAS,MAAO,MACxB,EAAO,KAAK,CAAG,CACjB,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,QAAS,CAChD,CAQA,SAAgB,EAAgB,EAAqC,CACnE,IAAM,EAAY,IAAI,EAAA,EAAU,CAAI,EAC9B,EAAkB,CAAC,EACzB,GAAI,CACF,OAAS,CACP,IAAM,EAAM,EAAU,QAAQ,EAC9B,GAAI,EAAI,OAAS,MAAO,MACxB,EAAO,KAAK,CAAG,CACjB,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,QAAS,CAChD,OAAS,EAAG,CACV,IAAM,EACJ,aAAa,EAAA,EACT,EACA,IAAI,EAAA,EAAe,aAAa,MAAQ,EAAE,QAAU,OAAO,CAAC,CAAC,EAC7D,EAAQ,EAAU,cACxB,GAAI,EAAQ,EAAK,OAAQ,CACvB,IAAI,EAAO,EACP,EAAM,EACV,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,IACrB,EAAK,KAAO;GACd,IACA,EAAM,GAEN,IAGJ,EAAO,KAAK,CACV,KAAM,QACN,MAAO,EAAK,MAAM,CAAK,EACvB,IAAK,EAAK,MAAM,CAAK,EACrB,OACA,MACA,OAAQ,EACR,UAAW,EAAK,MAClB,CAAC,CACH,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,SAAU,OAAM,CACvD,CACF"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/cdn/index.ts"],"sourcesContent":["/**\n * Public lower-level CDN tokenization and serialization API\n * (`@cbortech/cbor/cdn`).\n *\n * Exposes the same lexer the parser uses, so tooling such as syntax\n * highlighters stays in exact agreement with parsing behavior. Also exposes\n * the `preserveAppSeqSource` source-preservation primitives that the built-in\n * `dt`/`ip`/`cri` extensions use, so a third-party `CborExtension` whose\n * result has its own dedicated notation (regenerated from a resolved value,\n * the way `dt'...'`/`ip'...'`/`cri'...'` do) can support `preserveAppSeqSource`\n * too, instead of always discarding the original `` prefix`...` ``,\n * non-canonical `prefix'...'`, or raw-tag `N(...)` source spelling. See the\n * `dt`/`ip`/`cri` extension sources for the pattern these are meant to be\n * used in.\n */\n\nimport { Tokenizer, type Token, type EdnComment } from './tokenizer';\nimport { CdnSyntaxError } from './errors';\n\nexport type { Token, TokenType, EdnComment } from './tokenizer';\nexport { CdnSyntaxError } from './errors';\n\nexport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n  decideTaggedAppSeqRendering,\n  adjustRawAppSeqSource,\n  adjustAppSeqIndicator,\n} from './serialize-utils';\nexport type { AppSeqRenderDecision } from './serialize-utils';\n\nexport interface TokenizeResult {\n  /** Scanned tokens in source order, excluding the final EOF token. */\n  tokens: Token[];\n  /** Comments encountered while scanning, in source order. */\n  comments: EdnComment[];\n}\n\nexport interface TokenizeLenientResult extends TokenizeResult {\n  /**\n   * The scan failure, if any. When set, `tokens` ends with a synthetic\n   * `ERROR` token covering the source from the last clean token to the end\n   * of the input.\n   */\n  error?: CdnSyntaxError;\n}\n\n/**\n * Tokenize CDN text. Throws {@link CdnSyntaxError} on invalid input.\n */\nexport function tokenize(text: string): TokenizeResult {\n  const tokenizer = new Tokenizer(text);\n  const tokens: Token[] = [];\n  for (;;) {\n    const tok = tokenizer.consume();\n    if (tok.type === 'EOF') break;\n    tokens.push(tok);\n  }\n  return { tokens, comments: tokenizer.comments };\n}\n\n/**\n * Error-tolerant tokenization for editors and highlighters: never throws on\n * invalid input. Tokens before the failure are returned as scanned; the\n * remainder of the input is covered by a single synthetic `ERROR` token and\n * the failure is reported in `error`.\n */\nexport function tokenizeLenient(text: string): TokenizeLenientResult {\n  const tokenizer = new Tokenizer(text);\n  const tokens: Token[] = [];\n  try {\n    for (;;) {\n      const tok = tokenizer.consume();\n      if (tok.type === 'EOF') break;\n      tokens.push(tok);\n    }\n    return { tokens, comments: tokenizer.comments };\n  } catch (e) {\n    const error =\n      e instanceof CdnSyntaxError\n        ? e\n        : new CdnSyntaxError(e instanceof Error ? e.message : String(e));\n    const start = tokenizer.lastEndOffset;\n    if (start < text.length) {\n      let line = 1;\n      let col = 1;\n      for (let i = 0; i < start; i++) {\n        if (text[i] === '\\n') {\n          line++;\n          col = 1;\n        } else {\n          col++;\n        }\n      }\n      tokens.push({\n        type: 'ERROR',\n        value: text.slice(start),\n        raw: text.slice(start),\n        line,\n        col,\n        offset: start,\n        endOffset: text.length,\n      });\n    }\n    return { tokens, comments: tokenizer.comments, error };\n  }\n}\n"],"mappings":"sHAkDA,SAAgB,EAAS,EAA8B,CACrD,IAAM,EAAY,IAAI,EAAA,EAAU,CAAI,EAC9B,EAAkB,CAAC,EACzB,OAAS,CACP,IAAM,EAAM,EAAU,QAAQ,EAC9B,GAAI,EAAI,OAAS,MAAO,MACxB,EAAO,KAAK,CAAG,CACjB,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,QAAS,CAChD,CAQA,SAAgB,EAAgB,EAAqC,CACnE,IAAM,EAAY,IAAI,EAAA,EAAU,CAAI,EAC9B,EAAkB,CAAC,EACzB,GAAI,CACF,OAAS,CACP,IAAM,EAAM,EAAU,QAAQ,EAC9B,GAAI,EAAI,OAAS,MAAO,MACxB,EAAO,KAAK,CAAG,CACjB,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,QAAS,CAChD,OAAS,EAAG,CACV,IAAM,EACJ,aAAa,EAAA,EACT,EACA,IAAI,EAAA,EAAe,aAAa,MAAQ,EAAE,QAAU,OAAO,CAAC,CAAC,EAC7D,EAAQ,EAAU,cACxB,GAAI,EAAQ,EAAK,OAAQ,CACvB,IAAI,EAAO,EACP,EAAM,EACV,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,IACrB,EAAK,KAAO;GACd,IACA,EAAM,GAEN,IAGJ,EAAO,KAAK,CACV,KAAM,QACN,MAAO,EAAK,MAAM,CAAK,EACvB,IAAK,EAAK,MAAM,CAAK,EACrB,OACA,MACA,OAAQ,EACR,UAAW,EAAK,MAClB,CAAC,CACH,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,SAAU,OAAM,CACvD,CACF"}

package/dist/cdn/index.js

@@ -1,35 +1,35 @@
-import { D as e, _ as t, i as n, n as r, r as i, s as a, t as o } from "../tokenizer-N-vAvRdj.js";
+import { A as e, C as t, I as n, n as r, o as i, r as a, t as o } from "../serialize-utils-h-CVB9rg.js";
 //#region src/cdn/index.ts
-function s(e) {
-	let t = new o(e), n = [];
+function s(t) {
+	let n = new e(t), r = [];
 	for (;;) {
-		let e = t.consume();
+		let e = n.consume();
 		if (e.type === "EOF") break;
-		n.push(e);
+		r.push(e);
 	}
 	return {
-		tokens: n,
-		comments: t.comments
+		tokens: r,
+		comments: n.comments
 	};
 }
 function c(t) {
-	let n = new o(t), r = [];
+	let r = new e(t), i = [];
 	try {
 		for (;;) {
-			let e = n.consume();
+			let e = r.consume();
 			if (e.type === "EOF") break;
-			r.push(e);
+			i.push(e);
 		}
 		return {
-			tokens: r,
-			comments: n.comments
+			tokens: i,
+			comments: r.comments
 		};
-	} catch (i) {
-		let a = i instanceof e ? i : new e(i instanceof Error ? i.message : String(i)), o = n.lastEndOffset;
+	} catch (e) {
+		let a = e instanceof n ? e : new n(e instanceof Error ? e.message : String(e)), o = r.lastEndOffset;
 		if (o < t.length) {
 			let e = 1, n = 1;
 			for (let r = 0; r < o; r++) t[r] === "\n" ? (e++, n = 1) : n++;
-			r.push({
+			i.push({
 				type: "ERROR",
 				value: t.slice(o),
 				raw: t.slice(o),
@@ -40,13 +40,13 @@ function c(t) {
 			});
 		}
 		return {
-			tokens: r,
-			comments: n.comments,
+			tokens: i,
+			comments: r.comments,
 			error: a
 		};
 	}
 }
 //#endregion
-export { e as CdnSyntaxError, r as adjustAppSeqIndicator, i as adjustRawAppSeqSource, n as canonicalEncodingWidth, a as decideTaggedAppSeqRendering, t as resolveEiSuffix, s as tokenize, c as tokenizeLenient };
+export { n as CdnSyntaxError, o as adjustAppSeqIndicator, r as adjustRawAppSeqSource, a as canonicalEncodingWidth, i as decideTaggedAppSeqRendering, t as resolveEiSuffix, s as tokenize, c as tokenizeLenient };
 
 //# sourceMappingURL=index.js.map