@cbortech/cbor 0.26.6 → 0.26.8

package/README.ja.md

@@ -330,6 +330,27 @@ CBOR.format('`\\d+`', { preserveRawString: true });
 // '`\\d+`'
 ```
 
+### 数値リテラルの表記を保持する
+
+デフォルトでは、`CBOR.format()` は整数・浮動小数点数リテラルを正規化します。
+16進数・8進数・2進数の整数(`0xff`、`0o377`、`0b101`)は10進数に変換され、
+末尾のゼロや冗長なエンコーディング指標のサフィックス(`1.50`、`1.5_1`)は
+省略されます。`preserveNumberFormat` を指定すると、これらのリテラルを元の
+CDN ソース表記のまま再出力します。`intFormat` / `floatFormat` より優先され
+ます。CDN テキストからパースされたリテラルにのみ効果があり、`CBOR.from()`
+で構築した値や CBOR バイト列からデコードした値には効果がありません(通常
+どおりの整形になります)。
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+CBOR.format('{"a": 0xff, "b": 1.50}');
+// '{"a":255,"b":1.5}'
+
+CBOR.format('{"a": 0xff, "b": 1.50}', { preserveNumberFormat: true });
+// '{"a":0xff,"b":1.50}'
+```
+
 ### `+` による文字列連結を保持する
 
 注意: `+` による文字列連結構文は draft-26 で削除されました。この節は legacy
@@ -364,6 +385,110 @@ CBOR.format("h'68' + b64'aQ'", {
 //   b64'aQ'
 ```
 
+### application-string / -sequence 記法を保持する
+
+一部の組み込み拡張(`dt`/`DT`、`ip`/`IP`)は同じ値に対して `prefix'...'`
+(application string)、`` prefix`...` ``(backtick application string)、
+`prefix<<...>>`(application sequence)、生のタグリテラル(`N(...)`)の
+いずれの記法もサポートしていますが、デフォルトでは `CBOR.format()` を呼ぶ
+たびに解決済みの値から `prefix'...'` を再生成します。そのため
+`` DT`1969-07-21T02:56:16Z` `` も `DT<<'1969-07-21T02:56:16Z'>>` も、生の
+タグ記法 `1(1749772800)` さえも、すべて `DT'...'` 記法に正規化され、さら
+に非正規な `DT'...'` の表記(例えば `Z` の代わりに `+00:00` を使った場合
+など)も書き換えられます。`preserveAppSequence` を指定すると、実際に使わ
+れていた表記のまま保持します。`appStrings: false` を同時に指定した場合は
+効果がありません(どちらにせよ元の表記に関わらず生のタグ記法になるため)。
+これらの記法からパースされていない値にも効果はありません。
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+CBOR.format('1(1749772800)');
+// "DT'2025-06-13T00:00:00Z'"
+
+CBOR.format('1(1749772800)', { preserveAppSequence: true });
+// "1(1749772800)"
+
+CBOR.format("DT<<'1969-07-21T02:56:16Z'>>", { preserveAppSequence: true });
+// "DT<<'1969-07-21T02:56:16Z'>>"
+
+CBOR.format('DT`1969-07-21T02:56:16Z`', { preserveAppSequence: true });
+// "DT`1969-07-21T02:56:16Z`"
+```
+
+### 空行を保持する
+
+デフォルトでは、`CBOR.format()` は配列・マップの要素間(および `(_ ...)`
+のチャンク間)の空行を再シリアライズ時に取り除きます。`preserveBlankLines`
+を指定すると、元のソースでその要素の前のどこかに空行があった場合、要素の
+直前に空行を 1 行だけ再出力します。要素をパラグラフのようにまとめる元の
+見た目を、フォーマット後も保てます。元の空行が何行連続していても、出力
+されるのは常に 1 行だけです。判定は要素の位置だけに基づいており、
+`preserveComments` は不要で、コメントを出力するかどうかにも影響されません。
+`indent` を指定して整形出力する場合のみ効果があり、空行を保持する
+コンテナは `inlineLeafContainers` が有効でも常に 1 要素 1 行で出力されます。
+`preserveAll` にも含まれます。
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+const src = `[
+  1,
+  2,
+
+  3
+]`;
+
+CBOR.format(src, { indent: 2 });
+// [
+//   1,
+//   2,
+//   3
+// ]
+
+CBOR.format(src, { indent: 2, preserveBlankLines: true });
+// [
+//   1,
+//   2,
+//
+//   3
+// ]
+```
+
+### 変更を最小限にとどめてフォーマットする
+
+`preserveAll` を指定すると、すべての `preserve*` 系オプションが一括で
+有効になります。たとえばエディタの保存時フォーマットのように、空白・
+インデントだけを変更し、ほとんどのリテラルの元の表記には手を加えずに
+CDN テキストを整形できます(bignum だけは例外です。上記の
+`preserveNumberFormat` の説明を参照してください)。個別のオプションを
+明示的に指定した場合(`false` も含む)は、そちらが `preserveAll` より
+優先されます。
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+CBOR.format('{"a":0xff,"b":1.5_1,"c":b64\'aGk=\'}', {
+  indent: 2,
+  preserveAll: true,
+});
+// {
+//   "a": 0xff,
+//   "b": 1.5_1,
+//   "c": b64'aGk='
+// }
+```
+
+`CBOR.format()` は内部で `fromCDN()` と `toCDN()` の両方に同じオプション
+を渡すため、このオプション一つで済みます。両者を別々に呼び出す場合は、
+コメントはパース時に取り込んでおく必要があるため、`fromCDN()` 側にも
+`preserveAll`(または `preserveComments`)を指定してください。
+
+```ts
+const item = CBOR.fromCDN(text, { preserveAll: true });
+item.toCDN({ preserveAll: true, indent: 2 });
+```
+
 ### CBOR / CDN / hex dump のバリデーション
 
 `validate` は入力の well-formedness と validity を、例外を投げずにチェックします。

package/README.md

@@ -336,6 +336,26 @@ CBOR.format('`\\d+`', { preserveRawString: true });
 // '`\\d+`'
 ```
 
+### Preserve number literal spelling
+
+By default, `CBOR.format()` normalizes integer and floating-point literals:
+hex/octal/binary integers (`0xff`, `0o377`, `0b101`) become decimal, trailing
+zeros and redundant encoding-indicator suffixes (`1.50`, `1.5_1`) are
+dropped. `preserveNumberFormat` re-emits these literals using their original
+CDN source spelling instead, taking precedence over `intFormat` /
+`floatFormat`. It only affects literals parsed from CDN text — values built
+with `CBOR.from()` or decoded from CBOR bytes always use normal formatting.
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+CBOR.format('{"a": 0xff, "b": 1.50}');
+// '{"a":255,"b":1.5}'
+
+CBOR.format('{"a": 0xff, "b": 1.50}', { preserveNumberFormat: true });
+// '{"a":0xff,"b":1.50}'
+```
+
 ### Preserve `+` string concatenation
 
 Note: `+` string concatenation was removed in draft-26. This section is for
@@ -372,6 +392,110 @@ CBOR.format("h'68' + b64'aQ'", {
 //   b64'aQ'
 ```
 
+### Preserve application-string/-sequence notation
+
+Some built-in extensions (`dt`/`DT`, `ip`/`IP`) support `prefix'...'`
+(application string), `` prefix`...` `` (backtick application string),
+`prefix<<...>>` (application sequence), and a raw tag literal (`N(...)`)
+notation for the same value, and by default regenerate `prefix'...'` from
+the resolved value on every `CBOR.format()` call — so
+`` DT`1969-07-21T02:56:16Z` ``, `DT<<'1969-07-21T02:56:16Z'>>`, and even the
+raw tag form `1(1749772800)` all normalize to `DT'...'` notation, and a
+non-canonical `DT'...'` spelling (e.g. a `+00:00` offset instead of `Z`)
+gets rewritten too. `preserveAppSequence` keeps the original spelling
+instead — whichever form was used. It has no effect when
+`appStrings: false` is also set (raw tag notation is used either way
+regardless of the original spelling), or on values not parsed from one of
+these forms.
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+CBOR.format('1(1749772800)');
+// "DT'2025-06-13T00:00:00Z'"
+
+CBOR.format('1(1749772800)', { preserveAppSequence: true });
+// "1(1749772800)"
+
+CBOR.format("DT<<'1969-07-21T02:56:16Z'>>", { preserveAppSequence: true });
+// "DT<<'1969-07-21T02:56:16Z'>>"
+
+CBOR.format('DT`1969-07-21T02:56:16Z`', { preserveAppSequence: true });
+// "DT`1969-07-21T02:56:16Z`"
+```
+
+### Preserve blank lines
+
+By default, `CBOR.format()` drops blank lines between array/map entries (and
+`(_ ...)` chunks) when re-serializing. `preserveBlankLines` re-emits a single
+blank line above an entry that had one anywhere before it in the source, so
+paragraph-like groupings of entries survive a reformat — at most one blank
+line per gap, regardless of how many were originally there. Detection is
+based on entry positions alone: it does not require `preserveComments` and is
+unaffected by whether comments are emitted. Only effective when `indent`
+enables pretty-printing; a container with a preserved blank line is always
+rendered one entry per line, even under `inlineLeafContainers`. Included in
+`preserveAll`.
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+const src = `[
+  1,
+  2,
+
+  3
+]`;
+
+CBOR.format(src, { indent: 2 });
+// [
+//   1,
+//   2,
+//   3
+// ]
+
+CBOR.format(src, { indent: 2, preserveBlankLines: true });
+// [
+//   1,
+//   2,
+//
+//   3
+// ]
+```
+
+### Format with minimal changes
+
+`preserveAll` turns on every `preserve*` option at once, to reformat CDN
+text — e.g. when reformatting on save in an editor — touching only
+whitespace/indentation and leaving most literals' original spelling
+untouched (bignums are the one exception; see `preserveNumberFormat`
+above). An explicitly-set individual option (including `false`) still wins
+over `preserveAll`.
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+CBOR.format('{"a":0xff,"b":1.5_1,"c":b64\'aGk=\'}', {
+  indent: 2,
+  preserveAll: true,
+});
+// {
+//   "a": 0xff,
+//   "b": 1.5_1,
+//   "c": b64'aGk='
+// }
+```
+
+`CBOR.format()` passes the same options to both `fromCDN()` and `toCDN()`
+internally, so this one option is enough. Calling them separately needs
+`preserveAll` (or `preserveComments`) on the `fromCDN()` side too, since
+comments must be captured while parsing to be re-emittable later:
+
+```ts
+const item = CBOR.fromCDN(text, { preserveAll: true });
+item.toCDN({ preserveAll: true, indent: 2 });
+```
+
 ### Validate CBOR / CDN / hex dump
 
 `validate` checks input for well-formedness and validity without throwing.

package/dist/ast/CborByteString.d.ts

@@ -1,11 +1,25 @@
 import { ToCDNOptions, ToJSOptions, ToCBOROptions } from '../types';
 import { CborItem } from './CborItem';
 import { CborWriter, EncodingWidth } from '../cbor/encode';
+import { ByteCommentSyntax } from '../cdn/serialize-utils';
 /** One part of a byte string parsed from a CDN `+` concatenation chain. */
 export interface CborByteStringPart {
     bytes: Uint8Array;
     /** Original literal source text, when the part came from a byte string token. */
     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 {
@@ -15,12 +29,23 @@ export declare class CborByteString extends CborItem {
     readonly ednEncoding: 'hex' | 'base64' | 'base64url' | 'base32' | 'base32hex';
     encodingWidth: EncodingWidth | undefined;
     readonly ednSource: string | undefined;
+    /**
+     * Which comment syntax `ednSource` recognizes, if any — set once at parse
+     * time by whoever actually knows the literal's real origin (see
+     * `ByteCommentSyntax`), never re-derived later from its prefix string:
+     * a user extension can register under any prefix, including one a
+     * built-in (`b32`/`h32`) also uses, so the prefix string alone can't say
+     * which comment rules (if any) actually apply. `undefined` when
+     * `ednSource` has no comment syntax, or its extension's isn't known.
+     */
+    readonly ednCommentSyntax: ByteCommentSyntax | undefined;
     /** Part boundaries of the original `+` concatenation chain, if any. */
     readonly ednParts: readonly CborByteStringPart[] | undefined;
     constructor(value: Uint8Array, options?: {
         ednEncoding?: 'hex' | 'base64' | 'base64url' | 'base32' | 'base32hex';
         encodingWidth?: EncodingWidth;
         ednSource?: string;
+        ednCommentSyntax?: ByteCommentSyntax;
         ednParts?: readonly CborByteStringPart[];
     });
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;

package/dist/ast/CborEllipsis.d.ts

@@ -3,9 +3,101 @@ import { CborTag } from './CborTag';
 import { CborItem } from './CborItem';
 export declare const CPA888_TAG = 888n;
 export declare class CborEllipsis extends CborTag {
+    /**
+     * For the array (string/bytes elision) form: `realBoundary[i]` is `true`
+     * when a genuine `+` from the source precedes `items[i]` — as opposed to
+     * `items[i]` sitting *inside* a single `h'xx...yy'` literal's own `...`
+     * notation (index 0's value is never consulted — there is nothing before
+     * the first item). `preserveConcatenation` uses this to show only the
+     * real boundaries and fuse everything else, exactly as each source
+     * literal was spelled.
+     *
+     * `undefined` means no boundary information is available at all (e.g.
+     * reconstructed from raw CBOR bytes, which carry no notion of "was there
+     * a `+` here" to begin with) — `preserveConcatenation` then has no effect,
+     * the same as for a value that didn't originate from CDN source.
+     */
+    readonly realBoundary: readonly boolean[] | undefined;
+    /**
+     * For a subtree-elision placeholder (`888(null)`, i.e. `content
+     * instanceof CborSimple`) that sits *inside* another `CborEllipsis`'s
+     * items: `true` when it came from a `h'xx...yy'`-family literal's own
+     * `...` notation — even a fully-elided `h'...'` with no hex digits at all
+     * — as opposed to a bare standalone `...` token. Only consulted when this
+     * placeholder ends up isolated as its own preserved fragment (nothing to
+     * fuse it with on either side), to pick the right spelling: `h'...'` vs
+     * plain `...`.
+     */
+    readonly fromByteLiteral: boolean;
+    /**
+     * When `fromByteLiteral` is `true`: that `h'xx...yy'`-family literal's own
+     * raw source text (e.g. `h'AB...CD'` verbatim — case, interior whitespace,
+     * and any `/ ... /`/`# ...` comments included), for `preserveByteString`
+     * to round-trip instead of re-emitting a freshly lower-cased, comment-free
+     * `h'...'` literal. `undefined` when `fromByteLiteral` is `false`.
+     */
+    readonly literalSource: string | undefined;
     /** Subtree elision: 888(null) */
-    constructor();
+    constructor(fromByteLiteral?: boolean, literalSource?: string);
     /** String/bytes elision: 888([items...]) */
-    constructor(items: CborItem[]);
+    constructor(items: CborItem[], realBoundary?: readonly boolean[]);
     _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    /**
+     * `true` when this bytes elision has at least one real `+` boundary
+     * somewhere — as opposed to being a single `h'xx...yy'` literal's own
+     * `...` notation, which is not "produced by + concatenation" (see
+     * `preserveByteString`'s own docs) and so has its spelling preserved by
+     * `preserveByteString` alone, the same as a non-elided `h'...'` literal.
+     *
+     * A real boundary can hide two ways: as `realBoundary[i]` (`i > 0`) on the
+     * items array itself, or *inside* a merged `CborByteString` whose
+     * `ednParts.length > 1` — two `+`-joined literals that sat next to each
+     * other with no ellipsis between them (e.g. `h'AB' + h'CD...EF'`) merge
+     * into one item during parsing, so their boundary doesn't show up in
+     * `realBoundary` at that item's own index.
+     */
+    private _hasRealConcatenation;
+    /**
+     * Render one elision fragment as it should appear under
+     * `preserveConcatenation`: a merged multi-part `CborTextString` (see the
+     * parser's `currentParts` consolidation) is expanded back into its
+     * original `+`-joined literals, single-line, honoring `preserveRawString`
+     * per part. Anything else (a single-part fragment, or a nested
+     * `CborEllipsis`) renders normally.
+     *
+     * Only reached for text elision (or anything not shaped like a pure bytes
+     * elision, or a bytes elision with no `realBoundary` information) —
+     * `_renderPreservedBytesElision` handles the bytes case that has that
+     * information, since it needs to see all the fragments together to know
+     * which `...`s are real `+`-joined ellipses and which are internal to one
+     * `h'...'` literal.
+     */
+    private _renderFragment;
+    /**
+     * Re-emit a `888([...])` bytes elision as a single `h'xx...yy'` literal
+     * when every item is either a plain `CborByteString` fragment or a
+     * subtree-elision placeholder (`888(null)`) — i.e. exactly what
+     * `h'xx...yy'` parses into. Returns `undefined` when the items don't
+     * match that shape (e.g. text-string elision, or a fragment that isn't a
+     * plain byte string), so the caller falls back to the `frag + ... + frag`
+     * form.
+     */
+    private _compactHexElided;
+    /**
+     * `preserveConcatenation` rendering for a bytes elision. Groups the
+     * fragments at every *real* boundary (`realBoundary[i]`) and renders each
+     * group as one unit — fusing together whatever sits between real
+     * boundaries, including any `h'xx...yy'` literal's own internal `...`
+     * (wherever it's positioned — leading, trailing, or in the middle) and
+     * the fragments on either side of it, exactly as that literal was
+     * written. Within a group, a `CborByteString` that itself merged several
+     * `+`-joined literals (`ednParts.length > 1`, always a real boundary
+     * internally — see the parser) is further split at each of those parts.
+     *
+     * Returns `undefined` when there's no `realBoundary` to work from, or an
+     * item isn't a plain `CborByteString` or subtree-elision placeholder
+     * (e.g. text elision), so the caller falls back to the compact literal or
+     * the simpler per-fragment `frag + ... + frag` rendering.
+     */
+    private _renderPreservedBytesElision;
 }

package/dist/ast/CborFloat.d.ts

@@ -25,6 +25,15 @@ export declare class CborFloat extends CborItem {
      * to round-trip the literal when `appStrings` is not false.
      */
     ednSource?: string;
+    /**
+     * Original CDN literal source text (e.g. `1.50`, `1.5_1`, `0x1.8p+0_1`),
+     * set by the parser when this float came from a plain CDN float literal
+     * (as opposed to a `float'...'` app-string, which uses `ednSource`
+     * above). Used by `_toCDN()` to round-trip the literal's exact spelling,
+     * including its encoding-indicator suffix, when `preserveNumberFormat`
+     * is set.
+     */
+    literalSource?: string;
     /**
      * Original encoded payload bytes (big-endian, without the initial byte),
      * set by the decoder when the value is NaN so that NaN payloads survive a
@@ -36,6 +45,7 @@ export declare class CborFloat extends CborItem {
     constructor(value: number, options?: {
         precision?: FloatPrecision;
         rawBits?: Uint8Array;
+        literalSource?: string;
     });
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;
     _toCDN(options: ToCDNOptions | undefined, _depth: number): string;

package/dist/ast/CborItem.d.ts

@@ -1,4 +1,4 @@
-import { CBOROptions, ToCDNOptions, ToJSOptions, ToHexDumpOptions, ToCBOROptions, CborComments, DecodeWarning, ParseWarning } from '../types';
+import { CBOROptions, ToCDNOptions, ToJSOptions, ToHexDumpOptions, ToCBOROptions, CborComment, CborComments, DecodeWarning, ParseWarning } from '../types';
 import { CborWriter } from '../cbor/encode';
 /** @internal One line of an annotated hex dump. */
 export interface AnnotatedLine {
@@ -6,6 +6,27 @@ export interface AnnotatedLine {
     hex: string;
     comment: string;
 }
+export interface AppSeqEncodingEdit {
+    /** Start/end offsets within appSeqSource of an existing indicator. */
+    start: number;
+    end: number;
+    /** Replacement used by encodingIndicators: 'always'. */
+    always: string;
+    /** Replacement used by encodingIndicators: 'never'. */
+    never: string;
+}
+/**
+ * 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`.
+ */
+export interface AppSeqSourceFeatures {
+    byteString?: boolean;
+    textString?: boolean;
+    rawString?: boolean;
+    concatenation?: boolean;
+}
 /**
  * Abstract base class for all CBOR AST nodes.
  *
@@ -31,6 +52,71 @@ export declare abstract class CborItem {
      * They do not affect CBOR bytes or JS conversion.
      */
     comments?: CborComments;
+    /**
+     * `true` when this node is an array/map entry (or indefinite-length
+     * string chunk) immediately preceded by a blank line in the parsed CDN
+     * source — set unconditionally by the parser, regardless of any
+     * `preserve*` option, mirroring `start`/`end`. Only consulted by
+     * `toCDN()` when `ToCDNOptions.preserveBlankLines` is set; otherwise
+     * ignored. Left `undefined` for nodes not parsed as a container entry, or
+     * with no blank line before them.
+     */
+    blankLineBefore?: boolean;
+    /**
+     * Original application-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
+     * spelling instead of always regenerating `prefix'...'` notation from the
+     * resolved value. Left `undefined` for nodes not parsed from one of these
+     * forms.
+     */
+    appSeqSource?: string;
+    /**
+     * 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.
+     */
+    appSeqComments?: CborComment[];
+    /**
+     * Source edits for encoding indicators contained in a raw-tag
+     * `appSeqSource`. Includes zero-width edits where an indicator was absent
+     * so `encodingIndicators: 'always'` can insert one without regenerating
+     * the surrounding source.
+     */
+    appSeqEncodingEdits?: AppSeqEncodingEdit[];
+    /**
+     * `false` when `appSeqEncodingEdits` does not cover every encoding
+     * indicator nested inside a raw-tag `appSeqSource` — i.e. its content
+     * contains a node type `collectContentEncodingEdits` doesn't know how to
+     * edit (e.g. a `CborMap`, `CborTag`, or indefinite-length string inside an
+     * `ip` array). Left `undefined` (treated as complete) when coverage is
+     * exhaustive, which holds for every tag content type `dt` accepts and for
+     * most content `ip` accepts. When `false`, `decideTaggedAppSeqRendering`
+     * must not choose the `'source'` decision under `encodingIndicators !==
+     * 'auto'`, since surgical span edits would silently leave the uncovered
+     * node's indicator unchanged; it falls back to `'structural'` instead.
+     */
+    appSeqEncodingEditsComplete?: boolean;
+    /**
+     * For an `appSeqSource` parsed from `prefix<<item>>` notation: the offset
+     * within `appSeqSource`, relative to its own start, where the sole inner
+     * item's own consumption ends — i.e. right after its own encoding
+     * indicator, if it had one. Lets `adjustAppSeqIndicator` locate and strip
+     * that inner indicator exactly, regardless of what (whitespace, a
+     * trailing comma, a comment) separates it from the closing `>>`, rather
+     * than pattern-matching text near `>>`. `undefined` when `appSeqSource`
+     * isn't `<<...>>` notation, or wasn't captured with a single inner item.
+     */
+    appSeqInnerEnd?: number;
+    /**
+     * Literal-preservation features present in the sole item of a captured
+     * `prefix<<item>>` source. Used to resolve explicitly disabled
+     * `preserve*` options without treating unrelated options as conflicts.
+     */
+    appSeqSourceFeatures?: AppSeqSourceFeatures;
     /**
      * Validity violations detected while decoding or parsing this node.
      * Populated when `strict: false` is set in `FromCBOROptions` or
@@ -46,9 +132,12 @@ export declare abstract class CborItem {
     /**
      * @internal
      * True when this node is, or contains through wrapper nodes (tags,
-     * embedded CBOR, app-sequence results), an array or map.
-     * `inlineLeafContainers` never inlines a container whose entries contain
-     * another container, even one that renders on a single line.
+     * app-sequence results), an array or map. `inlineLeafContainers` never
+     * inlines a container whose entries contain another container, even one
+     * that renders on a single line. `CborEmbeddedCBOR` (`<<...>>`) is the one
+     * exception: it inlines its own entries based purely on whether they
+     * render without a line break, regardless of this flag — see its
+     * `_toCDN()`, which omits `entryIsLeaf` for that reason.
      */
     get _containsCdnContainer(): boolean;
     /** Serialize this node to CBOR binary. */

package/dist/ast/CborNint.d.ts

@@ -16,8 +16,17 @@ export declare class CborNint extends CborItem {
     /** CBOR raw argument n, where actual value = −1 − n. */
     readonly argument: bigint;
     encodingWidth: EncodingWidth | undefined;
+    /**
+     * Original CDN digit spelling (sign + base + digits, without the
+     * encoding-indicator suffix), set by the parser when this value came
+     * from CDN text. Used by `_toCDN()` to round-trip the literal's base
+     * (`-0xff`, `-0o377`, `-0b101`, decimal) when `preserveNumberFormat` is
+     * set.
+     */
+    readonly ednSource?: string;
     constructor(value: number | bigint, options?: {
         encodingWidth?: EncodingWidth;
+        ednSource?: string;
     });
     /** The actual decoded negative value (−1 − argument). */
     get value(): bigint;

package/dist/ast/CborSimple.d.ts

@@ -12,12 +12,21 @@ import { CborWriter } from '../cbor/encode';
  */
 export declare class CborSimple extends CborItem {
     readonly value: number;
-    constructor(value: number);
+    /**
+     * Original CDN digit spelling of the argument to `simple(...)` (base +
+     * digits), set by the parser when this value came from CDN text. Used by
+     * `_toCDN()` to round-trip the argument's base (`0x10`, decimal, …) when
+     * `preserveNumberFormat` is set.
+     */
+    readonly ednSource?: string;
+    constructor(value: number, options?: {
+        ednSource?: string;
+    });
     static readonly FALSE: CborSimple;
     static readonly TRUE: CborSimple;
     static readonly NULL: CborSimple;
     static readonly UNDEFINED: CborSimple;
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;
-    _toCDN(_options: ToCDNOptions | undefined, _depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
     _toJS(_options?: ToJSOptions): unknown;
 }

package/dist/ast/CborTag.d.ts

@@ -6,8 +6,16 @@ export declare class CborTag extends CborItem {
     readonly tag: bigint;
     readonly content: CborItem;
     encodingWidth: EncodingWidth | undefined;
+    /**
+     * Original CDN digit spelling of the tag number (base + digits, without
+     * the encoding-indicator suffix), set by the parser when this tag came
+     * from CDN text. Used by `_toCDN()` to round-trip the tag number's base
+     * (`0x3e7`, decimal, …) when `preserveNumberFormat` is set.
+     */
+    ednSource?: string;
     constructor(tag: number | bigint, content: CborItem, options?: {
         encodingWidth?: EncodingWidth;
+        ednSource?: string;
     });
     get _containsCdnContainer(): boolean;
     _encodeTo(writer: CborWriter, options?: ToCBOROptions): void;