@cbortech/cbor 0.26.7 → 0.27.0

package/dist/ast/CborByteString.d.ts

@@ -9,6 +9,17 @@ export interface CborByteStringPart {
     source?: string;
     /** Which comment syntax `source` recognizes, if any — see `ednCommentSyntax`. */
     commentSyntax?: ByteCommentSyntax;
+    /**
+     * Source span of this part's own literal token, when known — used to place
+     * a comment sitting between two `+`-joined parts (attached to the whole
+     * `CborByteString` as a `dangling` comment, since there is no per-part AST
+     * node for it to attach to) at the right gap in `_toCDN`'s
+     * `preserveConcatenation` branch. `undefined` for a part merged from a
+     * single elided literal's own internal segments, which cannot have a
+     * comment between them.
+     */
+    start?: number;
+    end?: number;
 }
 /** CBOR Major Type 2 — definite-length byte string. */
 export declare class CborByteString extends CborItem {
@@ -37,6 +48,22 @@ export declare class CborByteString extends CborItem {
         ednCommentSyntax?: ByteCommentSyntax;
         ednParts?: readonly CborByteStringPart[];
     });
+    /**
+     * Only the "bare sqstr text with 2+ words" case — the "is this a
+     * prefixed literal" question is deliberately *not* predicted here from
+     * raw bytes at all (a subclass like `CborIpExt` might override `_toCDN()`
+     * to render something else entirely, e.g. a preserved
+     * `ip<<'192.0.2.42'>>` app-sequence spelling, that raw-byte prediction
+     * knows nothing about — see `isMultiWordByteString`'s doc). That
+     * question is instead answered from the *actual rendering*: for a bare
+     * entry, `serializeContainer`'s own `isPrefixedLiteralText(s)` check
+     * already covers it (this node's render *is* `s`, unobscured); for one
+     * wrapped in a `CborTag`, `CborTag._isMultiWordText`'s
+     * `isMultiWordRenderedLiteral` check covers it instead. `strict` isn't
+     * needed here at all now — it's accepted purely for interface
+     * consistency with the base class.
+     */
+    _isMultiWordText(options: ToCDNOptions | undefined, _strict?: boolean): boolean;
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;
     _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
     _toJS(_options?: ToJSOptions): unknown;

package/dist/ast/CborEmbeddedCBOR.d.ts

@@ -2,7 +2,7 @@ import { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';
 import { CborItem, AnnotatedLine } from './CborItem';
 import { CborWriter, EncodingWidth } from '../cbor/encode';
 /**
- * CBOR Sequence Literal (§2.5.6) — `<<item, item, ...>>`.
+ * CBOR Sequence Literal (§2.3.4) — `<<item, item, ...>>`.
  *
  * Encodes as a definite-length byte string whose value is the concatenation
  * of the CBOR encodings of the contained items.

package/dist/ast/CborFloat.d.ts

@@ -22,7 +22,7 @@ export declare class CborFloat extends CborItem {
     /**
      * Original app-string source (e.g. `float'7e00'`), set by the parser when
      * this float is the result of a `float'...'` app-string.  Used by toCDN()
-     * to round-trip the literal when `appStrings` is not false.
+     * to round-trip the literal when `appPrefix` is not false.
      */
     ednSource?: string;
     /**

package/dist/ast/CborIndefiniteByteString.d.ts

@@ -8,6 +8,30 @@ export declare class CborIndefiniteByteString extends CborItem {
     readonly chunks: CborByteString[];
     constructor(chunks: CborByteString[]);
     _encodeTo(writer: CborWriter, options?: ToCBOROptions): void;
+    /**
+     * True when any chunk's own decoded content, if it renders as bare sqstr
+     * text, has two or more words. Reachable when this node is a *direct*
+     * entry of another container (`[(_ "two words")]`) — though even then,
+     * its own `_toCDN()` already self-disqualifies internally in that case
+     * (a multi-word chunk forces a multi-line self-render), which the
+     * ordinary "entry's own rendering has a line break" check would catch
+     * regardless of what this method answers, so this mostly exists for
+     * robustness/consistency with `CborTextString`/`CborByteString` rather
+     * than because some case is otherwise unreachable.
+     *
+     * `CborAppSeqResult`, which wraps this node for results like
+     * `ilbs<<...>>`, does *not* delegate to this method — it tokenizes its
+     * own rendered output directly instead (`isMultiWordRenderedLiteral`),
+     * which is exactly why `ilbs<<h'00'>>` stays an ordinary leaf (checked
+     * under the loose rule, matching `<<...>>`) while `[h'00']`/`(_ h'00')`
+     * still always disqualify — this method's own `_strict` (always `true`,
+     * matching how a chunk renders when this container *is* regenerated
+     * directly) plays no part in that distinction anymore, and a byte string
+     * chunk's own `_isMultiWordText` doesn't consult `strict` at all
+     * regardless (see `CborByteString`'s doc — its "prefixed literal" case
+     * was removed there too).
+     */
+    _isMultiWordText(options: ToCDNOptions | undefined, _strict?: boolean): boolean;
     _toCDN(options: ToCDNOptions | undefined, depth: number): string;
     _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[];
     _toJS(_options?: ToJSOptions): unknown;

package/dist/ast/CborIndefiniteTextString.d.ts

@@ -8,6 +8,22 @@ export declare class CborIndefiniteTextString extends CborItem {
     readonly chunks: CborTextString[];
     constructor(chunks: CborTextString[]);
     _encodeTo(writer: CborWriter, options?: ToCBOROptions): void;
+    /**
+     * True when any chunk is multi-word. Reachable when this node is a
+     * *direct* entry of another container (`[(_ "two words")]`) — though even
+     * then, its own `_toCDN()` already self-disqualifies internally in that
+     * case, producing a multi-line self-render that the ordinary "entry's own
+     * rendering has a line break" check would catch regardless of what this
+     * method answers, so this mostly exists for robustness/consistency with
+     * `CborTextString`/`CborByteString` rather than because some case is
+     * otherwise unreachable. (`CborAppSeqResult`, which wraps this node for
+     * results like `ilts<<...>>`, does *not* delegate to this method — it
+     * tokenizes its own rendered output directly instead; see its doc for
+     * why that turned out to be necessary.) `_strict` is intentionally
+     * unused: a chunk is always CborTextString, whose own word count doesn't
+     * depend on it.
+     */
+    _isMultiWordText(options: ToCDNOptions | undefined, _strict?: boolean): boolean;
     _toCDN(options: ToCDNOptions | undefined, depth: number): string;
     _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[];
     _toJS(_options?: ToJSOptions): unknown;

package/dist/ast/CborItem.d.ts

@@ -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;
@@ -63,11 +63,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 +77,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 +140,46 @@ 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.
+     */
+    _isMultiWordText(_options: ToCDNOptions | undefined, _strict?: boolean): boolean;
     /** Serialize this node to CBOR binary. */
     toCBOR(options?: ToCBOROptions): Uint8Array;
     /** Serialize this node to a CDN text string. */

package/dist/ast/CborTag.d.ts

@@ -18,6 +18,33 @@ 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): boolean;
     _encodeTo(writer: CborWriter, options?: ToCBOROptions): void;
     _toCDN(options: ToCDNOptions | undefined, depth: number): string;
     _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[];

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`
@@ -33,6 +33,18 @@ export declare class CborTextString extends CborItem {
      * `textString`.
      */
     readonly ednPartIsByteString: readonly boolean[] | undefined;
+    /**
+     * Source span of each `ednParts` entry's own literal token, aligned by
+     * index — used to place a comment sitting between two `+`-joined parts at
+     * the right gap instead of dropping it (there is no per-part AST node for
+     * such a comment to attach to; it lands as `dangling` on this whole node
+     * instead — see `CborByteString.ednParts`'s equivalent doc). `undefined`
+     * for a node not parsed from a `+` chain at all.
+     */
+    readonly ednPartSpans: readonly {
+        start: number;
+        end: number;
+    }[] | undefined;
     constructor(value: string, options?: {
         encodingWidth?: EncodingWidth;
         ednParts?: readonly string[];
@@ -40,7 +52,12 @@ export declare class CborTextString extends CborItem {
         quotedEdnSource?: string;
         ednPartSources?: readonly (string | undefined)[];
         ednPartIsByteString?: readonly boolean[];
+        ednPartSpans?: readonly {
+            start: number;
+            end: number;
+        }[];
     });
+    _isMultiWordText(_options: ToCDNOptions | undefined, _strict?: boolean): boolean;
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;
     _toCDN(options: ToCDNOptions | undefined, depth: number): 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-D2NyeCX3.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-C1f7G0AM.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.d.ts

@@ -1,4 +1,5 @@
 export { CborItem } from './CborItem';
+export type { AppSeqEncodingEdit, AppSeqSourceFeatures } from './CborItem';
 export { CborUint } from './CborUint';
 export { CborBigUint, CborBigNint } from './CborBignum';
 export { CborNint } from './CborNint';

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-DxrDre2P.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-CvLdiN0h.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-t_bdPk8_.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-iXpYtKQl.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-Bofmsptw.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-CNfrVRYp.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-EciPlN0n.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.o?i:new e.o(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.o,exports.tokenize=t,exports.tokenizeLenient=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../serialize-utils-CjTqQivB.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 API (`@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.\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 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":"gHAgCA,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.d.ts

@@ -2,6 +2,8 @@ import { Token, EdnComment } from './tokenizer';
 import { CdnSyntaxError } from './errors';
 export type { Token, TokenType, EdnComment } from './tokenizer';
 export { CdnSyntaxError } from './errors';
+export { resolveEiSuffix, canonicalEncodingWidth, decideTaggedAppSeqRendering, adjustRawAppSeqSource, adjustAppSeqIndicator, } from './serialize-utils';
+export type { AppSeqRenderDecision } from './serialize-utils';
 export interface TokenizeResult {
     /** Scanned tokens in source order, excluding the final EOF token. */
     tokens: Token[];

package/dist/cdn/index.js

@@ -1,7 +1,7 @@
-import { o as e, t } from "../tokenizer-CeuixxXi.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-BuIZPaUc.js";
 //#region src/cdn/index.ts
-function n(e) {
-	let n = new t(e), r = [];
+function s(t) {
+	let n = new e(t), r = [];
 	for (;;) {
 		let e = n.consume();
 		if (e.type === "EOF") break;
@@ -12,8 +12,8 @@ function n(e) {
 		comments: n.comments
 	};
 }
-function r(n) {
-	let r = new t(n), i = [];
+function c(t) {
+	let r = new e(t), i = [];
 	try {
 		for (;;) {
 			let e = r.consume();
@@ -24,19 +24,19 @@ function r(n) {
 			tokens: i,
 			comments: r.comments
 		};
-	} catch (t) {
-		let a = t instanceof e ? t : new e(t instanceof Error ? t.message : String(t)), o = r.lastEndOffset;
-		if (o < n.length) {
-			let e = 1, t = 1;
-			for (let r = 0; r < o; r++) n[r] === "\n" ? (e++, t = 1) : t++;
+	} 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++;
 			i.push({
 				type: "ERROR",
-				value: n.slice(o),
-				raw: n.slice(o),
+				value: t.slice(o),
+				raw: t.slice(o),
 				line: e,
-				col: t,
+				col: n,
 				offset: o,
-				endOffset: n.length
+				endOffset: t.length
 			});
 		}
 		return {
@@ -47,6 +47,6 @@ function r(n) {
 	}
 }
 //#endregion
-export { e as CdnSyntaxError, n as tokenize, r 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

package/dist/cdn/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/cdn/index.ts"],"sourcesContent":["/**\n * Public lower-level CDN tokenization API (`@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.\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 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":";;AAgCA,SAAgB,EAAS,GAA8B;CACrD,IAAM,IAAY,IAAI,EAAU,CAAI,GAC9B,IAAkB,CAAC;CACzB,SAAS;EACP,IAAM,IAAM,EAAU,QAAQ;EAC9B,IAAI,EAAI,SAAS,OAAO;EACxB,EAAO,KAAK,CAAG;CACjB;CACA,OAAO;EAAE;EAAQ,UAAU,EAAU;CAAS;AAChD;AAQA,SAAgB,EAAgB,GAAqC;CACnE,IAAM,IAAY,IAAI,EAAU,CAAI,GAC9B,IAAkB,CAAC;CACzB,IAAI;EACF,SAAS;GACP,IAAM,IAAM,EAAU,QAAQ;GAC9B,IAAI,EAAI,SAAS,OAAO;GACxB,EAAO,KAAK,CAAG;EACjB;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;EAAS;CAChD,SAAS,GAAG;EACV,IAAM,IACJ,aAAa,IACT,IACA,IAAI,EAAe,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,CAAC,GAC7D,IAAQ,EAAU;EACxB,IAAI,IAAQ,EAAK,QAAQ;GACvB,IAAI,IAAO,GACP,IAAM;GACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAO,KACzB,AAAI,EAAK,OAAO,QACd,KACA,IAAM,KAEN;GAGJ,EAAO,KAAK;IACV,MAAM;IACN,OAAO,EAAK,MAAM,CAAK;IACvB,KAAK,EAAK,MAAM,CAAK;IACrB;IACA;IACA,QAAQ;IACR,WAAW,EAAK;GAClB,CAAC;EACH;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;GAAU;EAAM;CACvD;AACF"}
+{"version":3,"file":"index.js","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":";;AAkDA,SAAgB,EAAS,GAA8B;CACrD,IAAM,IAAY,IAAI,EAAU,CAAI,GAC9B,IAAkB,CAAC;CACzB,SAAS;EACP,IAAM,IAAM,EAAU,QAAQ;EAC9B,IAAI,EAAI,SAAS,OAAO;EACxB,EAAO,KAAK,CAAG;CACjB;CACA,OAAO;EAAE;EAAQ,UAAU,EAAU;CAAS;AAChD;AAQA,SAAgB,EAAgB,GAAqC;CACnE,IAAM,IAAY,IAAI,EAAU,CAAI,GAC9B,IAAkB,CAAC;CACzB,IAAI;EACF,SAAS;GACP,IAAM,IAAM,EAAU,QAAQ;GAC9B,IAAI,EAAI,SAAS,OAAO;GACxB,EAAO,KAAK,CAAG;EACjB;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;EAAS;CAChD,SAAS,GAAG;EACV,IAAM,IACJ,aAAa,IACT,IACA,IAAI,EAAe,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,CAAC,GAC7D,IAAQ,EAAU;EACxB,IAAI,IAAQ,EAAK,QAAQ;GACvB,IAAI,IAAO,GACP,IAAM;GACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAO,KACzB,AAAI,EAAK,OAAO,QACd,KACA,IAAM,KAEN;GAGJ,EAAO,KAAK;IACV,MAAM;IACN,OAAO,EAAK,MAAM,CAAK;IACvB,KAAK,EAAK,MAAM,CAAK;IACrB;IACA;IACA,QAAQ;IACR,WAAW,EAAK;GAClB,CAAC;EACH;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;GAAU;EAAM;CACvD;AACF"}