@cbortech/cbor 0.26.7 → 0.27.0

package/dist/types.d.ts

@@ -43,7 +43,7 @@ export interface ToJSOptions {
      * - `'object'`: always `Record<string, unknown>` — non-string keys are
      *   converted via `String()`. Duplicate keys are overwritten (last wins).
      * - `'entries'`: always `MapEntries` (a typed `Array` subclass) — preserves all
-     *   entries including duplicate keys (§2.6.3 of draft-ietf-cbor-edn-literals-25).
+     *   entries including duplicate keys (§2.4.2 of draft-ietf-cbor-edn-literals-27).
      *   `fromJS()` recognises `MapEntries` instances and converts them back to `CborMap`.
      * @default 'auto'
      */
@@ -165,7 +165,7 @@ export interface FromCBOROptions {
      */
     extensions?: CborExtension[];
     /**
-     * Override the default set of bundled application-oriented extensions
+     * Override the default set of bundled app-extensions
      * (`dt`, `ip`, `cri`, `t1`, `b1`, `ilbs`, `ilts`, `float`).
      *
      * - omitted (default): use the standard bundled set.
@@ -173,13 +173,13 @@ export interface FromCBOROptions {
      * - `false`: disable all of them.
      *
      * `bignum` (tags 2/3) and embedded-CBOR (tag 24) support are core RFC 8949
-     * representation features, not application-oriented extensions, and are
-     * always active regardless of this option.
+     * representation features, not app-extensions, and are always active
+     * regardless of this option.
      *
-     * `dt`, `ip`, `t1`, and `b1` are mandatory-to-implement per §2.1 of
-     * draft-ietf-cbor-edn-literals-26; disabling them produces a decoder that
+     * `dt`, `ip`, `t1`, and `b1` are mandatory-to-implement per §3 of
+     * draft-ietf-cbor-edn-literals-27; disabling them produces a decoder that
      * no longer conforms to that recommendation. This is intended for
-     * allowlisting scenarios (see §7 Security considerations of the same
+     * allowlisting scenarios (see §8 Security considerations of the same
      * draft) where an application wants explicit control over which
      * extensions it accepts.
      */
@@ -254,7 +254,7 @@ export interface FromHexDumpOptions {
      */
     extensions?: CborExtension[];
     /**
-     * Override the default set of bundled application-oriented extensions.
+     * Override the default set of bundled app-extensions.
      * Mirrors `FromCBOROptions.builtinExtensions`.
      */
     builtinExtensions?: CborExtension[] | false;
@@ -332,7 +332,7 @@ export interface FromCDNOptions {
      */
     extensions?: CborExtension[];
     /**
-     * Override the default set of bundled application-oriented extensions
+     * Override the default set of bundled app-extensions
      * (`dt`, `ip`, `cri`, `t1`, `b1`, `ilbs`, `ilts`, `float`).
      *
      * - omitted (default): use the standard bundled set.
@@ -340,10 +340,10 @@ export interface FromCDNOptions {
      * - `false`: disable all of them; app-string literals using their
      *   prefixes then fall through to `unresolvedExtension` handling.
      *
-     * `dt`, `ip`, `t1`, and `b1` are mandatory-to-implement per §2.1 of
-     * draft-ietf-cbor-edn-literals-26; disabling them produces a parser that
+     * `dt`, `ip`, `t1`, and `b1` are mandatory-to-implement per §3 of
+     * draft-ietf-cbor-edn-literals-27; disabling them produces a parser that
      * no longer conforms to that recommendation. This is intended for
-     * allowlisting scenarios (see §7 Security considerations of the same
+     * allowlisting scenarios (see §8 Security considerations of the same
      * draft) where an application wants explicit control over which
      * extensions it accepts from untrusted CDN input.
      *
@@ -354,8 +354,8 @@ export interface FromCDNOptions {
      */
     builtinExtensions?: CborExtension[] | false;
     /**
-     * How to handle unrecognised application-extension identifiers
-     * (§4.1 of draft-ietf-cbor-edn-literals-25).
+     * How to handle unrecognised app-extension identifiers
+     * (§5.1 of draft-ietf-cbor-edn-literals-27).
      *
      * - `'cpa999'`: wrap the literal in a `CPA999` tag
      *   (`CborUnresolvedAppExt`) instead of failing. The resulting node
@@ -381,14 +381,28 @@ export interface FromCDNOptions {
      *
      * Comments are metadata only: they are ignored by CBOR binary encoding and
      * JavaScript conversion. Use together with `ToCDNOptions.preserveComments`
-     * to include them when formatting back to CDN.
+     * (or `comments`) to include them when formatting back to CDN.
      *
-     * The string values `'c-style'` and `'cdn-style'` are treated as `true`
-     * for parsing purposes; they become meaningful when passed to `toCDN()`.
+     * Passing `'c-style'`/`'cdn-style'` directly is a deprecated shorthand for
+     * `true` plus the equivalent `comments` — still accepted, but prefer
+     * `comments` for the output style going forward.
      *
      * @default false
      */
     preserveComments?: boolean | 'c-style' | 'cdn-style';
+    /**
+     * Companion to `preserveComments` for a single options object shared with
+     * `toCDN()` (as `CBOR.format()` does internally) — see
+     * `ToCDNOptions.comments` for what each value means there. On the
+     * parse side, only *whether* a style other than `'strip'` was requested
+     * matters: comments are captured when `preserveComments` is `true`, or
+     * when `comments` is set to anything other than `'strip'`. Left
+     * unset alongside an unset/`false` `preserveComments`, nothing is
+     * captured.
+     *
+     * @default undefined
+     */
+    comments?: 'strip' | 'c-style' | 'cdn-style';
     /**
      * Shorthand for `ToCDNOptions.preserveAll`, so a single option enables
      * round-tripping through both `fromCDN()` and `toCDN()` (as
@@ -457,10 +471,10 @@ export interface FromJSOptions {
      */
     extensions?: CborExtension[];
     /**
-     * Override the default set of bundled application-oriented extensions.
+     * Override the default set of bundled app-extensions.
      * Mirrors `FromCDNOptions.builtinExtensions`. Only affects builtins that
-     * implement `fromJS()` / `parseTag()` (none of the bundled application
-     * extensions implement `fromJS()` by default — use `dt_as_Date` via
+     * implement `fromJS()` / `parseTag()` (none of the bundled app-extensions
+     * implement `fromJS()` by default — use `dt_as_Date` via
      * `extensions` for `Date` round-tripping).
      */
     builtinExtensions?: CborExtension[] | false;
@@ -527,18 +541,22 @@ export interface ToCDNOptions {
      */
     indent?: number | string;
     /**
-     * Master switch that turns on every `preserve*` option below at once —
-     * `preserveComments`, `preserveByteString`, `preserveRawString`,
-     * `preserveTextString`, `preserveConcatenation`, `preserveNumberFormat`,
-     * `preserveAppSequence`, and `preserveBlankLines` — for reformatting CDN
-     * text (e.g. on save in an editor) with minimal changes: only
-     * whitespace/indentation, plus anything an explicitly-set individual
-     * option overrides.
+     * Master switch that turns on every `preserve*` option below at once,
+     * except the deprecated `preserveTextString` — `preserveComments`,
+     * `preserveByteString`, `preserveRawString`, `preserveConcatenation`,
+     * `preserveNumberFormat`, `preserveAppPrefix`, and
+     * `preserveBlankLines` — for reformatting CDN text (e.g. on save in an
+     * editor) with minimal changes: only whitespace/indentation, plus
+     * anything an explicitly-set individual option overrides.
      *
      * An option explicitly set to a value (including `false`) is left as-is;
      * `preserveAll` only fills in the ones left `undefined`. So
      * `{ preserveAll: true, preserveNumberFormat: false }` preserves
-     * everything except number literal spelling.
+     * everything except number literal spelling. `preserveComments` is filled
+     * in with `true` only when `comments` is *also* left unset — an
+     * explicit `comments` with no `preserveComments` still normalizes
+     * comments to that style under `preserveAll`, instead of being overridden
+     * by the verbatim fill-in.
      *
      * When parsing via `CBOR.fromCDN()` separately from `toCDN()` (rather
      * than through `CBOR.format()`, which passes the same options to both),
@@ -551,24 +569,45 @@ export interface ToCDNOptions {
      */
     preserveAll?: boolean;
     /**
-     * Emit comments previously captured by `FromCDNOptions.preserveComments`.
+     * Emit comments previously captured by `FromCDNOptions.preserveComments`,
+     * with their original markers kept as-is (no normalization) — takes
+     * precedence over `comments` when `true`.
+     *
+     * - `true`: emit comments verbatim, with whichever marker each one was
+     *   originally written with.
+     * - `false` / omitted: defer to `comments` (see below) — `'strip'` (the
+     *   default when that's also unset) or unset means no comments are
+     *   emitted.
+     * - `'c-style'` / `'cdn-style'`: deprecated shorthand for `false` plus the
+     *   equivalent `comments`; still accepted, but prefer setting
+     *   `comments` directly.
+     *
+     * Only effective when `indent` enables pretty-printing: single-line
+     * output strips all comments regardless, since line comments (`#`, `//`)
+     * can only be terminated by a newline.
+     *
+     * @default false
+     */
+    preserveComments?: boolean | 'c-style' | 'cdn-style';
+    /**
+     * Style to normalize comment markers to when emitting comments previously
+     * captured by `FromCDNOptions.preserveComments` — only consulted when
+     * `preserveComments` is not `true` (see there).
      *
-     * - `true`: emit comments with their original markers.
+     * - `'strip'` / omitted: don't emit comments at all.
      * - `'c-style'`: emit comments, normalising line comments to `//` and block
      *   comments to `/* … *\/`.
      * - `'cdn-style'`: emit comments, normalising line comments to `#` and block
      *   comments to `/ … /`. When a `/* … *\/` comment's content contains `/`
      *   (which cannot be represented inside `/ … /`), the `/* … *\/` form is
      *   kept as-is.
-     * - `false` / omitted: strip all comments from the output.
      *
-     * Only effective when `indent` enables pretty-printing: single-line
-     * output strips all comments, since line comments (`#`, `//`) can only
-     * be terminated by a newline.
+     * Only effective when `indent` enables pretty-printing; see
+     * `preserveComments`.
      *
-     * @default false
+     * @default 'strip'
      */
-    preserveComments?: boolean | 'c-style' | 'cdn-style';
+    comments?: 'strip' | 'c-style' | 'cdn-style';
     /**
      * Re-emit a blank line above an array/map entry (or indefinite-length
      * string chunk) that had one before it anywhere in the parsed CDN source,
@@ -594,7 +633,7 @@ export interface ToCDNOptions {
      * This preserves the spelling and interior layout of non-concatenated
      * `h'...'`, `b64'...'`, `b32'...'`, `h32'...'`, raw-backtick byte strings,
      * and single-quoted byte strings — including a `h'xx...yy'`-family elided
-     * literal (§4.2), whose spelling is kept independently of
+     * literal (§5.2), whose spelling is kept independently of
      * `preserveConcatenation` when it has no `+` of its own (see that
      * option). Byte strings produced by `+` concatenation are normalised as
      * usual; combine with `preserveConcatenation` to keep both the part
@@ -651,6 +690,13 @@ export interface ToCDNOptions {
      * In single-line output (no `indent`), a spelling that spans multiple
      * lines falls back to normal escaping; single-line spellings are kept.
      *
+     * @deprecated Verbatim spelling and `splitCdn` / `splitNewline` reflow
+     *   are mutually exclusive for a given literal — enabling this option
+     *   silently defeats both for any non-concatenated double-quoted string.
+     *   It still works when set explicitly, but no longer participates in
+     *   `preserveAll` and has been removed from the playground's preserve
+     *   options.
+     *
      * @default false
      */
     preserveTextString?: boolean;
@@ -703,16 +749,29 @@ export interface ToCDNOptions {
      */
     sqstr?: 'printable-string' | 'string' | 'none';
     /**
-     * Whether to use application-string / app-sequence notation for built-in
-     * extensions (e.g. `dt'...'`, `DT'...'`, `ip'...'`, `IP'...'`).
+     * Whether to use app-prefix notation — app-string (`dt'...'`, `` dt`...` ``)
+     * or app-sequence (`dt<<...>>`) — for built-in extensions.
      * - `true`: emit extension notation (`DT'2023-01-01T12:00:00Z'`)
      * - `false`: emit raw CBOR notation (`1(-14159024)`, `52(h'c000022a')`)
+     *
+     * Named after `app-prefix` (§6.1 of draft-ietf-cbor-edn-literals-27), the
+     * identifier both notations are built from — not just the app-string form,
+     * despite the old `appStrings` name (`false` also falls back to raw tag
+     * notation for a preserved app-sequence spelling; see `preserveAppPrefix`).
+     *
      * @default true
      */
+    appPrefix?: boolean;
+    /**
+     * @deprecated Renamed to `appPrefix` — the old name only described the
+     *   app-string form even though this option also gates app-sequence
+     *   (`<<...>>`) notation. Still honoured when `appPrefix` is left unset,
+     *   but `appPrefix` wins if both are set.
+     */
     appStrings?: boolean;
     /**
-     * For built-in extensions that support application-string notation
-     * (`prefix'...'` or `` prefix`...` ``), application-sequence notation
+     * For built-in extensions that support app-string notation
+     * (`prefix'...'` or `` prefix`...` ``), app-sequence notation
      * (`prefix<<...>>`), and/or a raw tag literal (`N(...)`), re-emit a value
      * using its exact original spelling instead of normalizing it to the
      * regenerated `prefix'...'` form.
@@ -722,10 +781,10 @@ export interface ToCDNOptions {
      * `` DT`1969-07-21T02:56:16Z` ``, `DT<<'1969-07-21T02:56:16Z'>>`, and even
      * the raw tag form `1(1749772800)` all become
      * `DT'2025-06-13T00:00:00Z'`-style `prefix'...'` notation, even though all
-     * of these denote the same value. `preserveAppSequence` keeps the
+     * of these denote the same value. `preserveAppPrefix` keeps the
      * original spelling instead — whichever quoting (`'...'` vs `` `...` ``),
      * bracketing (`<<...>>`), or raw tag form was used. Has no effect when
-     * `appStrings` is `false` (raw tag notation is used either way regardless
+     * `appPrefix` is `false` (raw tag notation is used either way regardless
      * of the original spelling), or on values not parsed from one of these
      * forms.
      *
@@ -733,13 +792,34 @@ export interface ToCDNOptions {
      * lines falls back to normal (regenerated) notation; single-line
      * spellings are kept.
      *
-     * An explicit `preserveComments` setting is still applied to comments
-     * inside a preserved application-sequence spelling: marker styles are
-     * normalised without changing the notation family, and `false` removes
-     * the comments while retaining the surrounding source spelling.
+     * An explicit `preserveComments`/`comments` setting is still applied
+     * to comments inside a preserved app-sequence spelling: marker styles are
+     * normalised without changing the notation family, and stripping comments
+     * (`preserveComments: false` with `comments` unset or `'strip'`)
+     * removes them while retaining the surrounding source spelling. Leaving
+     * *both* unset keeps the spelling's comments exactly as originally
+     * written, since nothing was explicitly requested.
+     *
+     * Named after `app-prefix` (§6.1 of draft-ietf-cbor-edn-literals-27; e.g.
+     * `dt`, `DT`, `ip`, `IP`), the identifier that `app-string`/`app-sequence`
+     * notation is built from. The raw tag literal case is still covered: it's
+     * the source spelling that used *no* app-prefix at all, and this option
+     * preserves that choice too, not just spellings that did use one.
+     * `preserveAppSequence` was the old, narrower name for this same option,
+     * since it also preserves app-string and raw-tag spellings, not just
+     * `<<...>>` sequences.
      *
      * @default false
      */
+    preserveAppPrefix?: boolean;
+    /**
+     * @deprecated Renamed to `preserveAppPrefix` — the old name only
+     *   described the `<<...>>` form even though this option also preserves
+     *   `prefix'...'` / `` prefix`...` `` and raw tag (`N(...)`) spellings.
+     *   Still honoured when `preserveAppPrefix` is left unset, but
+     *   `preserveAppPrefix` wins if both are set, and it no longer
+     *   participates in `preserveAll` (use `preserveAppPrefix` for that).
+     */
     preserveAppSequence?: boolean;
     /**
      * Numeric format for integer values in CDN output.
@@ -754,9 +834,25 @@ export interface ToCDNOptions {
      * Numeric format for floating-point values in CDN output.
      * - `'decimal'`: standard decimal notation (e.g. `1.5`, `145544.0_3`)
      * - `'hex'`: C99-style hex float notation (e.g. `0x1.8p+0`, `0x1.1c54p+17_3`)
+     * - `'app-extension'`: `float'...'` app-string notation carrying the
+     *   value's exact IEEE 754 bit pattern (e.g. `float'3fc00000'`), per §3.8
+     *   of draft-ietf-cbor-edn-literals-27. Unlike `'decimal'`/`'hex'`, this
+     *   is derived from the value's actual encoded bytes rather than its
+     *   numeric text, so it losslessly represents NaN payloads and
+     *   ±Infinity too (not just finite values). Falls back to `'decimal'`
+     *   when `appPrefix` is `false`, matching how other built-in extensions
+     *   fall back to raw notation.
+     *
+     * A value originally parsed from a `float'...'`/`float<<...>>` literal
+     * normally re-emits that exact source spelling regardless of this option
+     * (so its own encoding-width choice, or a non-canonical bit pattern, isn't
+     * silently normalized away) — leaving `floatFormat` unset, or setting it
+     * to `'app-extension'`, keeps that round-trip. Explicitly requesting
+     * `'decimal'` or `'hex'` opts out of it and reformats the value like any
+     * other float, since that's the point of asking for a different format.
      * @default 'decimal'
      */
-    floatFormat?: 'decimal' | 'hex';
+    floatFormat?: 'decimal' | 'hex' | 'app-extension';
     /**
      * Split long text strings using CDN string concatenation syntax (`"a" + "b"`).
      * Only effective when `indent` enables pretty-printing.
@@ -783,6 +879,11 @@ export interface ToCDNOptions {
      * `preserveConcatenation`; when it does not, the original concatenation
      * is preserved as usual.
      *
+     * `inlineLeafContainers` applies to the embedded CDN structure too: an
+     * array/map/`<<...>>` in the string content that would stay on one line
+     * as a real value keeps its split points collapsed here as well (e.g.
+     * `"[1, 2, 3]"` stays a single literal instead of splitting per element).
+     *
      * Replaces the deprecated `textStringFormat: ['cdn']`.
      *
      * @default false
@@ -818,8 +919,8 @@ export interface ToCDNOptions {
      * concatenation, and only takes effect when `indent` enables
      * pretty-printing (single-line output joins the parts into one literal).
      *
-     * Also applies within an elision (`...`, §4.2 of
-     * draft-ietf-cbor-edn-literals-25): a `+`-joined fragment on either side of
+     * Also applies within an elision (`...`, §5.2 of
+     * draft-ietf-cbor-edn-literals-27): a `+`-joined fragment on either side of
      * an ellipsis keeps its own part boundaries too (e.g. `'test' +
      * h'1234...abcd' + ...` stays exactly as written instead of merging
      * `'test'` into the byte fragment before it), and byte-string elision
@@ -835,17 +936,100 @@ export interface ToCDNOptions {
      */
     preserveConcatenation?: boolean;
     /**
-     * When pretty-printing with `indent`, keep a container on a single line
-     * when none of its entries contains an array or map (even wrapped in a
-     * tag) and every entry serializes without a line break (e.g. `[1, 2, 3]`,
-     * `{"a": 1}`, `(_ "a", "b")`). Nested leaf containers still collapse
-     * individually: `[[1, 2], [3, 4]]` renders with one inner array per line.
+     * Render preserved `+` string concatenation (see `preserveConcatenation`)
+     * or an elision chain (`...`, §5.2) using `t1<<...>>` / `b1<<...>>`
+     * app-sequence notation (draft-ietf-cbor-edn-literals-27 §3.5)
+     * instead of the legacy `+` operator.
+     *
+     * - `false` (default): `"a" + "b"` / `'test' + h'1234...abcd' + ...`.
+     * - `true`: `t1<<"a", "b">>` / `b1<<h'1234', h'..abcd'>>`. Falls back to
+     *   `false`'s rendering when `appPrefix` is `false`, since this notation
+     *   is itself an app-string form.
+     *
+     * For a plain (non-elision) concatenation, only changes the spelling used
+     * where `preserveConcatenation` already causes multi-part rendering; has
+     * no effect when concatenation collapses into a single merged literal
+     * (e.g. `preserveConcatenation` unset, or a text string whose content is
+     * reflowed by `splitCdn` instead). An elision chain is different: `...`
+     * denotes genuinely unknown content, so it always renders as multiple
+     * parts regardless of `preserveConcatenation` — `modernConcat` therefore
+     * also applies to it unconditionally (`preserveConcatenation` there only
+     * controls how much of a fragment's *own* internal boundary is shown, not
+     * whether the chain itself is shown as multiple parts).
+     *
+     * Has no effect on a value that was itself parsed from `t1<<...>>` /
+     * `b1<<...>>` source: when `appPrefix` is not `false`, `encodingIndicators`
+     * is `'auto'` (both defaults), and the source is either single-line or
+     * being rendered with `indent` enabled, that spelling is kept verbatim
+     * regardless of `modernConcat` (see `t1`/`b1` in
+     * [String Concatenation and Indefinite-Length Strings](../README.md#string-concatenation-and-indefinite-length-strings)).
+     * A multi-line source falls back to normalized (collapsed) output in
+     * single-line mode, since that layout can't be reproduced without
+     * `indent`. `modernConcat` only affects values reconstructed from a `+`
+     * chain.
      *
-     * `<<...>>` (CBOR Sequence Literal / embedded CBOR) is the one exception:
-     * since it's a flat sequence of encoded items rather than a
-     * nested-structure display, an entry that is itself an array/map still
-     * inlines there as long as its own rendering fits on one line — e.g.
-     * `<<{1: -7}>>` stays on one line, even though `[{1: -7}]` would not.
+     * @default false
+     */
+    modernConcat?: boolean;
+    /**
+     * Render an indefinite-length string using `ilts<<...>>` / `ilbs<<...>>`
+     * app-sequence notation (draft-ietf-cbor-edn-literals-27 §3.6)
+     * instead of the legacy `(_ "a", "b")` streamstring form.
+     *
+     * - `false` (default): `(_ "a", "b")`.
+     * - `true`: `ilts<<"a", "b">>` / `ilbs<<h'..', h'..'>>`. Falls back to
+     *   `false`'s rendering when `appPrefix` is `false`, since this notation
+     *   is itself an app-string form.
+     *
+     * Applies whenever an indefinite-length string is rendered as chunks;
+     * unaffected by `encodingIndicators: 'never'`, which merges the chunks
+     * into a single definite-length literal regardless of this option.
+     *
+     * Has no effect on a value that was itself parsed from `ilts<<...>>` /
+     * `ilbs<<...>>` source: when `appPrefix` is not `false`, `encodingIndicators`
+     * is `'auto'` (both defaults), and the source is either single-line or
+     * being rendered with `indent` enabled, that spelling is kept verbatim
+     * regardless of `modernStreamSyntax`. A multi-line source falls back to
+     * normalized (collapsed) output in single-line mode, since that layout
+     * can't be reproduced without `indent`. `modernStreamSyntax` only affects
+     * values reconstructed from a legacy `(_ ...)` chunk list.
+     *
+     * @default false
+     */
+    modernStreamSyntax?: boolean;
+    /**
+     * When pretty-printing with `indent`, keep an array, map, or
+     * indefinite-length string group (`(_ "a", "b")`) on a single line when
+     * none of its entries contains an array or map (even wrapped in a tag),
+     * none of its entries is a text string with two or more words (also even
+     * wrapped in a tag), and every entry serializes without a line break
+     * (e.g. `[1, 2, 3]`, `{"a": 1}`, `(_ "a", "b")`). Word boundaries follow
+     * `Intl.Segmenter`'s word-break rules, so `["hello", "world"]` still
+     * collapses to one line (each entry is a single word) while `["Hello,
+     * World!", "This is the CBOR library."]` renders one entry per line (each
+     * has two or more) — space-less scripts (Japanese, Chinese, ...) are still
+     * split on their own dictionary-based word boundaries. Nested leaf
+     * containers still collapse individually: `[[1, 2], [3, 4]]` renders with
+     * one inner array per line.
+     *
+     * `<<...>>` (CBOR Sequence Literal / embedded CBOR) is not governed by
+     * this option at all: its own parens never require an additional line
+     * break by themselves, regardless of `inlineLeafContainers`'s value,
+     * since (unlike an array, map, or indefinite-length string group) it has
+     * no nested-structure display of its own to spread out — it's a flat
+     * sequence of encoded items. Instead it stays on one line exactly when
+     * every entry's own actual rendering already does — an entry that is
+     * itself an array/map is not disqualified just for being one, unlike in
+     * an outer array/map. Concretely: `<<{1: -7}>>` renders as `<<{1: -7}>>`
+     * when `inlineLeafContainers` lets the inner map collapse to one line,
+     * but as `<<\n  {\n    1: -7\n  }\n>>` when it doesn't (the map itself
+     * still spreads one entry per line without the option, same as it would
+     * anywhere else — `<<...>>` just doesn't add a break of its own on top
+     * of that). `[{1: -7}]`, by contrast, always spreads its `{1: -7}` entry
+     * onto its own line regardless of whether the map itself collapses,
+     * since a nested array/map always disqualifies an outer array/map's
+     * entry. A two-or-more-word text entry still forces a break inside
+     * `<<...>>` either way, irrespective of `inlineLeafContainers`.
      *
      * Containers with preserved comments are always emitted in multi-line
      * form. Has no effect when `indent` is omitted.
@@ -916,12 +1100,12 @@ export interface ValidateOptions {
      */
     extensions?: CborExtension[];
     /**
-     * Override the default set of bundled application-oriented extensions.
+     * Override the default set of bundled app-extensions.
      * Mirrors `FromCBOROptions.builtinExtensions`.
      */
     builtinExtensions?: CborExtension[] | false;
     /**
-     * How to handle unrecognised application-extension identifiers.
+     * How to handle unrecognised app-extension identifiers.
      * Only applies when `type` is `'cdn'`; mirrors `FromCDNOptions.unresolvedExtension`.
      * @default 'cpa999'
      */
@@ -996,9 +1180,9 @@ export interface ValidateResult {
      */
     cddlWarnings?: CddlValidationWarning[];
 }
-/** `fromCBORSeq()` の options（`offset`/`allowTrailing` はジェネレータが管理するため除外）。 */
+/** Options for `fromCBORSeq()` (`offset`/`allowTrailing` are excluded — the generator manages them). */
 export type FromCBORSeqOptions = Omit<FromCBOROptions, 'offset' | 'allowTrailing'>;
-/** `fromCDNSeq()` の options（`offset`/`allowTrailing` はジェネレータが管理するため除外）。 */
+/** Options for `fromCDNSeq()` (`offset`/`allowTrailing` are excluded — the generator manages them). */
 export type FromCDNSeqOptions = Omit<FromCDNOptions, 'offset' | 'allowTrailing'>;
 /**
  * Combined options for the `CBOR` constructor.

package/dist/utils/base64.d.ts

@@ -2,7 +2,7 @@
  * Decode base64 text (classic or URL-safe alphabet, padding optional) into
  * bytes, with strict RFC 4648 validation.
  *
- * Used by the CDN parser (b64'…' literals, §5.3.4) and the CDDL tokenizer
+ * Used by the CDN parser (b64'…' literals, §6.2.2) and the CDDL tokenizer
  * (b64'…' byte strings, RFC 8610 §3.1).
  *
  * Recoverable deviations (padding-count mismatches, non-zero trailing bits)

package/dist/utils/hexfloat.d.ts

@@ -4,7 +4,7 @@
  * Hex float format:
  *   [-] 0x [hex digits] [. [hex digits]] p [+-] [decimal exponent]
  *
- * This notation appears in CDN (draft-ietf-cbor-edn-literals-25) as an
+ * This notation appears in CDN (draft-ietf-cbor-edn-literals-27) as an
  * alternative representation for floating-point values (major type 7).
  */
 /**

package/dist/utils/strip-comments.d.ts

@@ -1,5 +1,5 @@
 /**
- * Strip whitespace and EDN §2.2 comments from app-string content.
+ * Strip whitespace and EDN §2.1 comments from app-string content.
  *
  * Used by extensions whose content allows the same comment syntax as byte
  * string literals (b32, h32, float, …):

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@cbortech/cbor",
-  "version": "0.26.7",
+  "version": "0.27.0",
   "description": "Convert between CBOR, CDN (CBOR-EDN), and JavaScript values with CDDL validation",
   "keywords": [
     "cbor",
     "cdn",
     "cddl",
     "cddl-validation",
-    "rfc8610",
     "cbor-edn",
     "diagnostic-notation",
     "json",
@@ -90,12 +89,13 @@
     "build": "vite build",
     "prepack": "npm run build",
     "watch": "vite build --watch",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "node ./node_modules/typescript/bin/tsc --noEmit",
     "start": "node dist/index.js",
     "dev": "npm run build && npm start",
     "clean": "node -e \"['dist','coverage'].forEach(d=>require('fs').rmSync(d,{recursive:true,force:true}))\"",
     "test": "vitest run --exclude src/cdn/edn-test-vectors.test.ts --exclude src/cdn/edn-abnf-vectors.test.ts --exclude src/cddl/cddl-corpus.test.ts --exclude src/cddl/cddl-validation-vectors.test.ts --exclude site/src/playground.browser.test.ts",
     "test:exports": "npm run build && node scripts/check-package-exports.mjs",
+    "fetch-test-vectors": "node scripts/fetch-test-vectors.mjs",
     "test:node": "vitest run --exclude src/cdn/edn-test-vectors.test.ts --exclude src/cdn/edn-abnf-vectors.test.ts --exclude src/cddl/cddl-corpus.test.ts --exclude src/cddl/cddl-validation-vectors.test.ts --exclude site/src/playground.browser.test.ts",
     "test:edn-vectors": "vitest run src/cdn/edn-test-vectors.test.ts",
     "test:edn-abnf": "vitest run src/cdn/edn-abnf-vectors.test.ts",
@@ -120,16 +120,17 @@
   "devDependencies": {
     "@cbortech/hash-extension": "^0.2.3",
     "@types/node": "^24.13.3",
+    "@typescript/typescript6": "^6.0.2",
     "@vitest/browser": "^4.1.10",
     "@vitest/browser-playwright": "^4.1.10",
     "@vitest/coverage-v8": "^4.1.10",
     "@vitest/ui": "^4.1.10",
     "cross-env": "^10.1.0",
-    "playwright": "^1.61.1",
+    "playwright": "^1.62.1",
     "prettier": "^3.9.6",
-    "typescript": "^5.9.3",
-    "vite": "^8.1.5",
-    "vite-plugin-dts": "^4.5.4",
+    "typescript": "^7.0.2",
+    "vite": "^8.2.1",
+    "vite-plugin-dts": "^5.0.3",
     "vitest": "^4.1.10"
   }
 }