@cbortech/cbor 0.27.0 → 0.27.2

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import { CborExtension } from './extensions/types';
+import { CborItem } from './ast/CborItem';
 import { CddlSchema } from './cddl/schema';
 import { ValidateOptions as CddlValidateOptions } from './cddl/validator';
 import { CddlValidationError, CddlValidationWarning } from './cddl/errors';
@@ -14,6 +15,114 @@ import { CddlValidationError, CddlValidationWarning } from './cddl/errors';
  */
 export declare const CBOR_OMIT: unique symbol;
 export type { CborExtension } from './extensions/types';
+/**
+ * Context passed to an `itemOptions` callback (see `ToJSOptions.itemOptions`)
+ * describing where the node being visited sits in the tree.
+ */
+export interface ItemContext {
+    /**
+     * The direct parent AST node. `undefined` for the root value being
+     * converted. A tag or app-sequence wrapper is its content's `parent` —
+     * see `path` for how wrappers affect addressing.
+     */
+    parent?: CborItem;
+    /**
+     * The path segment identifying this node: an array index (`number`), or a
+     * map key's JS value (any type — CBOR keys are not limited to strings).
+     * Always equal to the last element of `path`, except `undefined` for the
+     * root value and while converting a map key itself (`isMapKey: true`),
+     * since a key has no path of its own — it names its sibling value's
+     * segment instead. A tag or app-sequence wrapper's content inherits the
+     * wrapper's own `key` (and `path`) unchanged, since the wrapper adds no
+     * segment of its own — see `path`.
+     */
+    key?: unknown;
+    /**
+     * The map key's own AST node, present when this node is a map entry's key
+     * or value — but *not* inherited into a tag/app-sequence wrapper's
+     * content the way `key`/`path` are, so it is only reliable at the map
+     * entry itself. Lets a callback inspect a non-scalar key structurally
+     * (e.g. via `keyNode._toCDN()`) instead of relying only on `key`'s
+     * computed JS value.
+     */
+    keyNode?: CborItem;
+    /**
+     * `true` when this invocation is for converting a map key itself, rather
+     * than one of that key's sibling value's descendants.
+     */
+    isMapKey?: boolean;
+    /**
+     * Path from the root to this node, as a sequence of array indices and map
+     * key JS values. Empty for the root value. A tag or app-sequence wrapper
+     * does not add a segment of its own — its content shares the wrapper's own
+     * path.
+     */
+    readonly path: readonly unknown[];
+    /**
+     * The options in effect for this node going into this call — i.e. the
+     * root options merged with whatever overrides its ancestors already
+     * returned, *before* this callback's own return value is merged on top.
+     * Read from this to build on the current value of an option (e.g. add an
+     * extension to whatever list is already in effect) instead of overriding
+     * it outright, or to make a decision based on an option's current value.
+     *
+     * A mutable-looking field here (currently just `extensions`) is a fresh
+     * copy, not the live array in effect elsewhere — mutating it in place
+     * (e.g. `ctx.options.extensions.push(ext)`) has no effect on this node,
+     * its siblings, or the caller's own options; return an override instead.
+     *
+     * Has no `reviver` — its type is `ReadonlyToJSNodeOptions`, not
+     * `ToJSOptions` — for the same reason this callback's own return value
+     * can't set one:
+     * since this callback may run more than once for the same node (see
+     * `ToJSOptions.itemOptions`), always reflecting only the reviver-
+     * independent options keeps what it reads consistent with what it can
+     * write, and keeps a callback that only inspects `options` pure across
+     * every one of those calls.
+     *
+     * @example
+     * // Add `dt_as_Date` to whatever extensions are already configured,
+     * // rather than replacing them.
+     * itemOptions: (_node, ctx) => ({
+     *   extensions: [...(ctx.options.extensions ?? []), dt_as_Date],
+     * })
+     */
+    readonly options: ReadonlyToJSNodeOptions;
+}
+/**
+ * `ToJSOptions` with `reviver` removed. Used wherever an API only ever
+ * needs to see the reviver-*independent* part of the options in effect for
+ * a node — an `itemOptions` callback's return value, and the `options`
+ * parameter of `CborExtension.toJS()` — because reviving the value a node
+ * converts to always happens afterwards, exactly once per visit, in the
+ * container holding it (see `CborArray`/`CborMap`); it is never something
+ * the conversion of the node itself should (or, for `CborExtension.toJS()`,
+ * even can) branch on. Keeping `reviver` out of both signatures — rather
+ * than merely documenting that it should be ignored — means neither can
+ * observe whether one is present, which is what makes it safe for a
+ * `reviver`-driven `CborArray`/`CborMap` to convert a child more than once
+ * (see `ToJSOptions.itemOptions`) without either one's result depending on
+ * *which* of those conversions it was called for.
+ */
+export type ToJSNodeOptions = Omit<ToJSOptions, 'reviver'>;
+/**
+ * `ToJSNodeOptions`, as handed to code that must not mutate it in place:
+ * `ItemContext.options` and the `options` parameter of
+ * `CborExtension.toJS()`. Both describe options actually in effect
+ * elsewhere in the tree, so mutating what's handed out here must not be
+ * able to reach that: reassigning a top-level property is a type error
+ * (`Readonly<...>`), and `extensions`, the one field on `ToJSOptions`
+ * that's an ordinary mutable array, is narrowed to a readonly array so an
+ * in-place mutation like `.push()` is one too. This only guards against
+ * *accidental* mutation via the type system — the implementation
+ * additionally hands out a fresh snapshot, with its own copy of
+ * `extensions`, on every call, so even a deliberate cast past this type
+ * can't corrupt what another node, sibling, hook, or pass sees (see
+ * `_toJSChild`'s `toReadonlyNodeOptions`).
+ */
+export type ReadonlyToJSNodeOptions = Readonly<Omit<ToJSNodeOptions, 'extensions'>> & {
+    readonly extensions?: readonly CborExtension[];
+};
 export interface ToHexDumpOptions {
     /**
      * Indentation per nesting level.
@@ -37,11 +146,19 @@ export interface ToJSOptions {
     integerAs?: 'auto' | 'number' | 'bigint';
     /**
      * How to represent CBOR map values when converting to JavaScript.
-     * - `'auto'`: text-string-only keys → `Record<string, unknown>`,
-     *   other key types → `Map<unknown, unknown>`.
-     *   Duplicate keys are silently overwritten (last value wins).
+     * - `'auto'`: `Record<string, unknown>` when every key is a text string,
+     *   or (with a CDDL `cddl` schema and `eRefKeys` not `false`) an e-ref
+     *   annotated integer key that resolves to its name string — `Map<unknown,
+     *   unknown>` for any other key type. Duplicate *text-string* keys are
+     *   silently overwritten (last value wins), same as `'object'` below —
+     *   but if a text-string key and an e-ref name key resolve to the same
+     *   property string (e.g. `&(title: -1)` alongside a literal `"title"`
+     *   key in the same map), `'auto'` falls back to `MapEntries` instead of
+     *   silently dropping one of them.
      * - `'object'`: always `Record<string, unknown>` — non-string keys are
-     *   converted via `String()`. Duplicate keys are overwritten (last wins).
+     *   converted via `String()`. Duplicate keys (including a text/e-ref
+     *   collision as above) are overwritten (last wins) — unlike `'auto'`,
+     *   `'object'` never falls back, since it was explicitly requested.
      * - `'entries'`: always `MapEntries` (a typed `Array` subclass) — preserves all
      *   entries including duplicate keys (§2.4.2 of draft-ietf-cbor-edn-literals-27).
      *   `fromJS()` recognises `MapEntries` instances and converts them back to `CborMap`.
@@ -58,6 +175,30 @@ export interface ToJSOptions {
      * @default false
      */
     stripTags?: boolean;
+    /**
+     * Whether a tag the CDDL schema itself implies is left off the JavaScript
+     * value — e.g. with `{ t: time }` (prelude `time = #6.1(number)`), the
+     * CBOR `{"t": 1(-14159024)}` (CDN `{"t": DT'1969-07-21T02:56:16Z'}`)
+     * converts to `{ t: -14159024 }` (a plain `number`) rather than a
+     * `Number` object carrying `Tag.symbol`.
+     *
+     * A tag counts as implied only where `FromJSOptions.implicitTags` would
+     * add it back when converting the result with the same schema, so
+     * `toJS()` → `fromJS()` still round-trips: it must be matched by a
+     * `#6.N(type)` with a literal tag number, and the untagged content must
+     * not be acceptable at that position on its own — under `time / number`
+     * a tagged `1(5)` keeps its tag, since plain `5` would stay untagged.
+     * Tags the schema doesn't require (`any`, `#6.<uint>(…)`, …) are always
+     * kept.
+     *
+     * Only takes effect for an item validated via `FromCBOROptions.cddl` /
+     * `FromCDNOptions.cddl` / `FromJSOptions.cddl`; without a schema, every
+     * tag is kept as before. Pass `false` to keep every tag even with one.
+     * `stripTags: true` removes all tags regardless.
+     *
+     * @default true
+     */
+    implicitTags?: boolean;
     /**
      * Post-conversion reviver function, applied bottom-up after the CBOR value
      * has been converted to JavaScript.
@@ -80,6 +221,110 @@ export interface ToJSOptions {
      * @default false
      */
     undefinedOmits?: boolean;
+    /**
+     * Extension plugins consulted during `toJS()`, tried in order for every
+     * node before its own default conversion. An extension takes part by
+     * implementing `CborExtension.toJS()`; the first one to return a result
+     * for a given node wins and that node's own `_toJS()` is not called.
+     *
+     * Unlike the `extensions` option on `FromCDNOptions`/`FromCBOROptions`,
+     * this does not affect parsing — it only lets `toJS()` reinterpret nodes
+     * that a *different* extension configuration already produced. For
+     * example, a tree parsed with the plain `dt` extension (`DT'...'` →
+     * `number`) can still be converted with `dt_as_Date` selected here
+     * (`DT'...'` → `Date`), and vice versa — see `itemOptions` below to apply
+     * this to only part of a tree.
+     *
+     * There is no `builtinExtensions` equivalent for `toJS()`: leaving this
+     * unset (the default) keeps every node's own built-in conversion
+     * behavior, so no bundled extension needs to be "re-added" here just to
+     * get default output.
+     */
+    extensions?: CborExtension[];
+    /**
+     * Called for every node during `toJS()`, before that node is converted,
+     * to override the options used for its subtree. Return a partial options
+     * object to merge over the options in effect for this node (they apply to
+     * this node and are inherited by its descendants, who may override them
+     * again); return `undefined` to make no change.
+     *
+     * This is the mechanism for applying an option — including `extensions`,
+     * to select a different conversion for one node without affecting its
+     * siblings — to only part of a document, keyed off `ctx.path` or the
+     * node's own shape (`item instanceof ...`).
+     *
+     * **May be called more than once for the same AST node.** With a
+     * `reviver` present, `CborArray`/`CborMap` convert each child at least
+     * twice: once (with `reviver` itself withheld from the options this
+     * callback sees, though its own return value is honoured as normal) to
+     * build a holder a `reviver` call can inspect via `this[j]` for a
+     * not-yet-processed sibling `j`, and once more, for real, to compute the
+     * value the container actually keeps — and a node several levels down
+     * can in principle be offered to this callback more than twice, if a
+     * container at some intermediate level runs a pre-population pass of its
+     * own while itself sitting inside an *outer* container's. Each call is
+     * independent and reflects only the state relevant to *that* particular
+     * conversion (e.g. `ctx.path` for a value under a composite map key
+     * shows whatever that key currently converts to, which can differ
+     * between an earlier, not-yet-revived call and a later one after the
+     * key's own `reviver` has run). Write this callback as a pure function of
+     * `item`/`ctx` — it must not assume, or count, how many times it runs.
+     *
+     * @example
+     * // Convert only `date1` with `dt_as_Date`, leaving other DT values as
+     * // the epoch numbers the tree was originally parsed with.
+     * item.toJS({
+     *   itemOptions: (node, ctx) =>
+     *     ctx.path.length === 1 && ctx.path[0] === 'date1'
+     *       ? { extensions: [dt_as_Date] }
+     *       : undefined,
+     * });
+     */
+    itemOptions?: (item: CborItem, ctx: ItemContext) => Partial<ToJSNodeOptions> | undefined;
+    /**
+     * Whether a map key annotated by CDDL `e'...'` external-reference
+     * resolution (draft-ietf-cbor-edn-e-ref) — an integer key the `cddl`
+     * schema names via a `&(name: value)` group entry at a map-member-key
+     * position, e.g. `? &(title: -1) => oltext` — converts to a plain-object
+     * key spelled as that name (`"title"`) instead of the integer itself. A
+     * general CDDL constant rule (`title = -1`) is not enough on its own to
+     * annotate a key this way — see `cddl/eref.ts`'s module doc — only
+     * `e'title'` written explicitly in CDN source resolves via a plain
+     * constant rule.
+     *
+     * Defaults to `true`: such a key exists at all only because some earlier
+     * `cddl`-validated decode/parse (or an `eRefKeys`-driven `fromJS()`, see
+     * `FromJSOptions.eRefKeys`) already named it, so leaving this option unset
+     * uses that name — pass `false` explicitly to fall back to the plain
+     * integer key instead (e.g. for code that reads `obj[-1]` and doesn't
+     * want it silently renamed to `obj.title`). A map with no CDDL-named keys
+     * at all is entirely unaffected either way — `mapAs: 'auto'`'s own choice
+     * between a plain object and `MapEntries` only ever treats a key as
+     * object-eligible via this option when the key is actually annotated;
+     * this is not a general "coerce integer keys to strings" switch.
+     *
+     * Only takes effect for a key CDDL validation has already annotated (see
+     * `FromCBOROptions.cddl` / `FromCDNOptions.cddl`); without a schema, or for
+     * a key the schema does not name this way, the key converts as usual.
+     * Annotation is unambiguous by construction (a name mapped to more than
+     * one value, or a value named more than once, in the same schema is
+     * excluded from annotation entirely — and a name ambiguous in either
+     * direction is excluded from *both*), so this never introduces a name
+     * collision on its own — though a name can still collide with an
+     * unrelated map's own genuine text-string key of the same spelling
+     * (e.g. `&(title: -1)` alongside a literal `"title"` key in the same
+     * map). `mapAs: 'auto'` treats that case differently from a plain
+     * duplicate text-string key: it detects the collision and falls back to
+     * `MapEntries` rather than silently dropping one side — see
+     * `ToJSOptions.mapAs`. An explicit `mapAs: 'object'` still overwrites
+     * (last value wins), the same as it does for any other non-injective key
+     * conversion. Only integer-valued names are annotated (see
+     * `cddl/eref.ts`'s Scope note) — a float, text, or byte-string map key is
+     * never affected.
+     *
+     * @default true
+     */
+    eRefKeys?: boolean;
 }
 export interface ToCBOROptions {
 }
@@ -525,7 +770,151 @@ export interface FromJSOptions {
      * Mirrors `FromCBOROptions.cddlValidationOptions`.
      */
     cddlValidationOptions?: CddlValidateOptions;
+    /**
+     * When not `false`, a plain object's property name that the `cddl` schema
+     * names — via a `&(name: value)` group entry at a map-member-key
+     * position (e.g. `? &(title: -1) => oltext`), or a bare reference to a
+     * constant rule at that same position — converts to that integer key
+     * instead of a text-string key, so `fromJS({ title: "oops" }, { cddl })`
+     * produces the same map `toJS()` on that map would read back as
+     * `{ title: "oops" }` (both options default to on, so neither needs
+     * spelling out explicitly to get a round-trip). The resulting key
+     * round-trips through `toCDN()` as `e'title'` the same way a
+     * schema-annotated key produced by `fromCBOR()`/`fromCDN()` does — only
+     * an unambiguous, integer-valued name is ever used this way (see
+     * `cddl/eref.ts`'s module doc).
+     *
+     * `ToJSOptions.eRefKeys` only ever renames an integer key some earlier
+     * step already labeled (`annotateERefKeys()`, run automatically after a
+     * successful `cddl`-validated decode/parse — or `e'name'` written
+     * explicitly in CDN source); this direction is different, since it
+     * *constructs* the key before any validation happens — so which names are
+     * even eligible is resolved **positionally**: only a name bound at a member-key position
+     * within the CDDL type actually governing *this* property's own position
+     * (starting from the schema's root rule, or `cddlValidationOptions.rule`
+     * when set, and descending through nested map types the same way this
+     * object's own nesting does) is used, never a name that merely exists
+     * *somewhere* in the schema. A property named `title` is therefore left
+     * as an ordinary text-string key unless the schema specifically names
+     * `title` at the exact position this object is being converted for —
+     * even if some unrelated, structurally unreachable rule elsewhere in the
+     * same schema happens to name `title` too (see `cddl/eRefScope.ts`'s own
+     * module doc, including its Scope note on what "governing type" this can
+     * and can't resolve).
+     *
+     * Only applies to a plain object's own properties (`Object.entries()`), not
+     * to a `MapEntries` key, which is preserved exactly as given (a native
+     * `Map` is not currently recognized by `fromJS()` at all — see its own
+     * doc — independent of `eRefKeys`) — a `MapEntries` entry's *value* still
+     * gets a nested scope when its own key is a string naming a known map
+     * property, the same way an ordinary property's value does, so a nested
+     * object reached this way still converts correctly; an array element
+     * never does, regardless. Without a schema, or for a property name the
+     * schema does not name this way at this exact position, the key converts as usual (a
+     * text-string key). Pass `false` explicitly to keep every property as a
+     * plain text-string key even when the schema would otherwise name one —
+     * e.g. for code that writes `{ title: "oops" }` and wants that spelled
+     * literally rather than resolved to `-1`. Requires `cddl` — has no effect
+     * on its own.
+     *
+     * @default true
+     */
+    eRefKeys?: boolean;
+    /**
+     * Whether a tag the CDDL schema requires is added to a value that lacks
+     * it — e.g. with `{ t: time }` (prelude `time = #6.1(number)`),
+     * `{ t: -14159024 }` (a plain `number`, no `Tag.symbol`) converts to
+     * `{"t": 1(-14159024)}` (CDN `{"t": DT'1969-07-21T02:56:16Z'}`). The
+     * mirror image of `ToJSOptions.implicitTags`.
+     *
+     * Inference is a fallback, never a rewrite of valid data: nothing is
+     * added when the converted value already matches the schema, and at
+     * every choice an alternative the value matches as-is wins — with
+     * `time / number`, a plain `5` stays `5`. Only a `#6.N(type)` with a
+     * literal tag number is inferred (the tag is created the same way a
+     * `Tag.symbol`-annotated value would be, so tag 1 becomes a `DT'…'`
+     * node); a value already carrying `Tag.symbol` is used as given. When
+     * even inference cannot make the value match, it is left unchanged and
+     * the usual `CddlMismatchError` is thrown.
+     *
+     * Requires `cddl` — has no effect on its own. Pass `false` to require
+     * every tag to be spelled out via `Tag.symbol`, as without a schema.
+     *
+     * @default true
+     */
+    implicitTags?: boolean;
 }
+/**
+ * Context passed to a `toCDN()` `itemOptions` callback (see
+ * `ToCDNOptions.itemOptions`) describing where the node being visited sits
+ * in the tree. Structurally the same shape as `ItemContext` (`toJS()`'s
+ * own per-item context — see there for the full rationale behind each
+ * field), but `path`'s map-key segments are derived the CDN way: a
+ * text-string key contributes its string value, any other key contributes
+ * its own `toCDN()` rendering — there is no "JS value" for a CDN key to
+ * contribute instead, since converting to JS is not what this call is
+ * doing.
+ *
+ * Unlike `ItemContext`, a node's `toCDN()` `itemOptions` callback can run
+ * more than once for reasons `toJS()`'s never does: `inlineLeafContainers`
+ * (and a tag/app-sequence value's own multi-word check) render an entry a
+ * second time, at the *same* depth and options, purely to answer a layout
+ * question (does it fit on one line? is it multi-word?) before the real
+ * render — an existing, deliberate characteristic of `toCDN()` itself (see
+ * `serializeContainer` in `cdn/serialize-utils.ts`), not something
+ * `itemOptions` introduces. Write this callback as a pure function of
+ * `item`/`ctx`, the same guidance as `ItemContext`'s own, for the same
+ * reason: it must not assume, or count, how many times it runs.
+ */
+export interface CdnItemContext {
+    /** The direct parent AST node. `undefined` for the root value being converted. */
+    parent?: CborItem;
+    /**
+     * The path segment identifying this node: an array index (`number`), or
+     * a map key's string value/`toCDN()` rendering (see `CdnItemContext`'s
+     * own note). Always equal to the last element of `path`, except
+     * `undefined` for the root value and while converting a map key itself
+     * (`isMapKey: true`). A tag or app-sequence wrapper's content inherits
+     * the wrapper's own `key` (and `path`) unchanged, since the wrapper adds
+     * no segment of its own.
+     */
+    key?: unknown;
+    /** The map key's own AST node, present when this node is a map entry's key or value. */
+    keyNode?: CborItem;
+    /**
+     * `true` when this invocation is for converting a map key itself, rather
+     * than one of that key's sibling value's descendants.
+     */
+    isMapKey?: boolean;
+    /**
+     * Path from the root to this node, as a sequence of array indices and
+     * map key identifiers (see `CdnItemContext`'s own note). Empty for the
+     * root value. A tag or app-sequence wrapper does not add a segment of
+     * its own — its content shares the wrapper's own path.
+     */
+    readonly path: readonly unknown[];
+    /**
+     * The options in effect for this node going into this call — the root
+     * options merged with whatever overrides its ancestors already
+     * returned, *before* this callback's own return value is merged on top.
+     * A mutable-looking field here (currently just the deprecated
+     * `textStringFormat`) is a fresh copy, not the live array in effect
+     * elsewhere — mutating it in place has no effect on this node, its
+     * siblings, or the caller's own options; return an override instead.
+     */
+    readonly options: ReadonlyToCDNOptions;
+}
+/**
+ * `ToCDNOptions`, as handed to code that must not mutate it in place —
+ * `CdnItemContext.options` — the `toCDN()` counterpart of
+ * `ReadonlyToJSNodeOptions`. `textStringFormat` (the one field on
+ * `ToCDNOptions` that's an ordinary mutable array, and already deprecated)
+ * is narrowed to a readonly array for the same reason `extensions` is
+ * there; see `ReadonlyToJSNodeOptions`'s own doc for the full rationale.
+ */
+export type ReadonlyToCDNOptions = Readonly<Omit<ToCDNOptions, 'textStringFormat'>> & {
+    readonly textStringFormat?: readonly TextStringFormat[];
+};
 export interface ToCDNOptions {
     /**
      * Indentation for pretty-printing.
@@ -1049,6 +1438,39 @@ export interface ToCDNOptions {
      * @default 'auto'
      */
     encodingIndicators?: 'always' | 'auto' | 'never';
+    /**
+     * Called for every node during `toCDN()`, before that node is rendered,
+     * to override the options used for its subtree. Return a partial options
+     * object to merge over the options in effect for this node (they apply to
+     * this node and are inherited by its descendants, who may override them
+     * again); return `undefined` to make no change.
+     *
+     * This is the mechanism for applying an option to only part of a
+     * document — e.g. rendering one array element in hex while the rest stay
+     * decimal — keyed off `ctx.path` or the node's own shape
+     * (`item instanceof ...`).
+     *
+     * **May be called more than once for the same AST node** — see
+     * `CdnItemContext`'s own note on why, and why this callback should be a
+     * pure function of `item`/`ctx` rather than relying on how many times it
+     * runs.
+     *
+     * Not called for keys of an indefinite-length string's chunks or a
+     * `<<...>>` sequence's items, which have no key of their own to convert
+     * (only array elements and map entries/keys have a `path` segment).
+     *
+     * @example
+     * // Render only the value at key "raw" using hex integers, leaving the
+     * // rest of the document in the default decimal format.
+     * item.toCDN({
+     *   indent: 2,
+     *   itemOptions: (_node, ctx) =>
+     *     ctx.path.length === 1 && ctx.path[0] === 'raw'
+     *       ? { intFormat: 'hex' }
+     *       : undefined,
+     * });
+     */
+    itemOptions?: (item: CborItem, ctx: CdnItemContext) => Partial<ToCDNOptions> | undefined;
 }
 export type TextStringFormat = 'newline' | 'cdn' | DeprecatedTextStringFormat;
 /** @deprecated Use `'cdn'` instead. */

package/dist/utils/hexfloat.d.ts

@@ -19,8 +19,16 @@ export declare function parseHexFloat(s: string): number;
  * Convert a JS number to a normalized hex float string compatible with
  * CDN diagnostic notation.
  *
- * - Normal values: `0x1.[hex fraction]p[+-][exp]`  (e.g. `0x1.8p+0` for 1.5)
- * - Subnormal values: `0x0.[hex fraction]p-1022`
+ * - Every nonzero finite value: `0x1.[hex fraction]p[+-][exp]` (e.g.
+ *   `0x1.8p+0` for 1.5) — including a *subnormal* double, renormalized
+ *   into this same leading-`1` form rather than spelled out anchored to
+ *   its own stored field layout (`0x0.[hex fraction]p-1022`, still a
+ *   correct spelling of the same value, but needlessly longer: e.g.
+ *   `Number.MIN_VALUE` used to read `0x0.0000000000001p-1022`, equal to
+ *   but far longer than the normalized `0x1p-1074`. A hex-float literal
+ *   is just `significand * 2^exponent` — there's no reason its spelling
+ *   should vary by whether the *double* happened to run out of exponent
+ *   range, once it's just text.)
  * - Zero: `0x0p+0` / `-0x0p+0`
  * - Non-finite values (NaN, ±Infinity) are returned unchanged as EDN tokens.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cbortech/cbor",
-  "version": "0.27.0",
+  "version": "0.27.2",
   "description": "Convert between CBOR, CDN (CBOR-EDN), and JavaScript values with CDDL validation",
   "keywords": [
     "cbor",
@@ -93,10 +93,10 @@
     "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": "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/**/*.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: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/**/*.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",
     "test:cddl-corpus": "vitest run src/cddl/cddl-corpus.test.ts",
@@ -118,19 +118,18 @@
     "site:test": "npm run build && npm run --workspace site test"
   },
   "devDependencies": {
-    "@cbortech/hash-extension": "^0.2.3",
-    "@types/node": "^24.13.3",
+    "@types/node": "^24.13.6",
     "@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",
+    "@vitest/browser": "^4.1.11",
+    "@vitest/browser-playwright": "^4.1.11",
+    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/ui": "^4.1.11",
     "cross-env": "^10.1.0",
-    "playwright": "^1.62.1",
-    "prettier": "^3.9.6",
+    "playwright": "^1.63.0",
+    "prettier": "^3.9.8",
     "typescript": "^7.0.2",
-    "vite": "^8.2.1",
-    "vite-plugin-dts": "^5.0.3",
-    "vitest": "^4.1.10"
+    "vite": "^8.3.0",
+    "vite-plugin-dts": "^5.1.1",
+    "vitest": "^4.1.11"
   }
 }