@cbortech/cbor 0.27.1 → 0.27.2

package/README.ja.md

@@ -1211,6 +1211,29 @@ const value = CBOR.parse('{"x": 12, "y": -3}', {
 検証オプションは `cddlValidationOptions` で渡せます。`cddl` は
 `new CBOR({ cddl: … })` のようにインスタンスのデフォルトにもできます。
 
+スキーマを指定すると、スキーマ自体が要求するタグは JavaScript 側で省略
+できます。`toJS()` は、prelude の `time = #6.1(number)` のような `#6.N(…)`
+型に一致したタグを外し、`fromJS()` はタグのない値にそれを補います。
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+const cddl = 'event = { t: time }';
+
+CBOR.parse(`{"t": DT'1969-07-21T02:56:16Z'}`, { cddl });
+// { t: -14159024 }（Tag.symbol のない素の number）
+
+CBOR.stringify({ t: -14159024 }, { cddl });
+// {"t":DT'1969-07-21T02:56:16Z'}
+```
+
+タグを外すのは `fromJS()` で復元できる場合だけです。タグなしの値もその
+位置で妥当な場合（`time / number`）や、スキーマがタグを要求しない場合
+（`any`）はタグを残します。推論は、値がそのままではスキーマに一致しない
+ときにだけ行います。すべてのタグを明示的に保持・要求するには
+`implicitTags: false`（`ToJSOptions` と `FromJSOptions` のオプション）を
+指定します。
+
 `CDDL.compile()` は `CddlSyntaxError` または `CddlSemanticError` を throw
 します。`{ strict: false }` を指定すると、意味上の問題を
 `schema.warnings` に収集できます。コンパイル済みスキーマは
@@ -1251,6 +1274,7 @@ CDDL コンパイラは `@cbortech/cbor/cddl`
 - CDN (CBOR-EDN)
   - [draft-ietf-cbor-edn-literals-25](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-literals/25/)
   - [draft-ietf-cbor-edn-literals-27](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-literals/27/)
+  - [draft-ietf-cbor-edn-e-ref-03](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-e-ref/03/)
 - CDDL
   - [RFC 8610](https://www.rfc-editor.org/rfc/rfc8610)
   - [RFC 9682](https://www.rfc-editor.org/rfc/rfc9682)
@@ -1267,6 +1291,9 @@ CDDL コンパイラは `@cbortech/cbor/cddl`
   `#6.<type>` / `#7.<type>` head number に対応しています。コメントの `PCHAR`
   検証、単独 CR の改行、EOF で終わるコメントは、collected ABNF よりも意図的に
   寛容に受理します。
+- draft-ietf-cbor-edn-e-ref の `e'...'` application extension を試験的に
+  サポートしています(draft本文より狭いスコープで、整数リテラルに直接束縛された
+  名前のみ対応 — 文字列定数や、他の定数への別名参照は解決できません)。
 
 ## ライセンス
 

package/README.md

@@ -1223,6 +1223,29 @@ Throwing methods such as `parse`, `decode`, and `encode` throw
 in `result.cddlErrors`. Pass validator options through `cddlValidationOptions`,
 or set `cddl` as an instance default with `new CBOR({ cddl: … })`.
 
+With a schema, tags the schema itself requires can be left implicit in
+JavaScript. `toJS()` drops a tag matched by a `#6.N(…)` type such as the
+prelude's `time = #6.1(number)`, and `fromJS()` adds it back to a value that
+lacks it:
+
+```ts
+import { CBOR } from '@cbortech/cbor';
+
+const cddl = 'event = { t: time }';
+
+CBOR.parse(`{"t": DT'1969-07-21T02:56:16Z'}`, { cddl });
+// { t: -14159024 } (a plain number, no Tag.symbol)
+
+CBOR.stringify({ t: -14159024 }, { cddl });
+// {"t":DT'1969-07-21T02:56:16Z'}
+```
+
+A tag is dropped only when `fromJS()` would restore it: it is kept where the
+untagged value is also valid on its own (`time / number`) or where the schema
+doesn't require it (`any`). Inference only runs when the value doesn't
+already match the schema. Pass `implicitTags: false` (a `ToJSOptions` and
+`FromJSOptions` option) to keep or require every tag explicitly.
+
 `CDDL.compile()` throws `CddlSyntaxError` or `CddlSemanticError`; use
 `{ strict: false }` to collect semantic issues in `schema.warnings` instead.
 Compiled schemas can be formatted with `schema.format()`. The subpath also
@@ -1263,6 +1286,7 @@ types).
 - CDN (CBOR-EDN)
   - [draft-ietf-cbor-edn-literals-25](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-literals/25/)
   - [draft-ietf-cbor-edn-literals-27](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-literals/27/)
+  - [draft-ietf-cbor-edn-e-ref-03](https://datatracker.ietf.org/doc/draft-ietf-cbor-edn-e-ref/03/)
 - CDDL
   - [RFC 8610](https://www.rfc-editor.org/rfc/rfc8610)
   - [RFC 9682](https://www.rfc-editor.org/rfc/rfc9682)
@@ -1280,6 +1304,10 @@ Implementation notes:
   `#7.<type>` head numbers. Comment `PCHAR` validation, bare CR line endings,
   and comments ending at EOF are intentionally accepted more leniently than the
   collected ABNF.
+- Experimental support for draft-ietf-cbor-edn-e-ref's `e'...'` application
+  extension, limited to names bound directly to an integer literal (the
+  draft's own scope is broader) — a string constant, or an alias to another
+  named constant, doesn't resolve.
 
 ## License
 

package/dist/ast/CborItem.d.ts

@@ -341,8 +341,10 @@ export declare abstract class CborItem {
      * (`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
+     * it wrap) a prefixed literal" question — a byte-string literal has no
+     * word count to check, and an app-string literal (`dt'...'`) is
+     * word-counted from its rendered content, but either disqualifies only
+     * 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
@@ -379,6 +381,19 @@ export declare abstract class CborItem {
      * it, the same as `strict`.
      */
     _isMultiWordText(_options: ToCDNOptions | undefined, _strict?: boolean, _path?: readonly unknown[]): boolean;
+    /**
+     * @internal
+     * Optional override: an alternate plain-string spelling to use as this
+     * node's `toJS()` object key, in place of `CborMap.toObject()`'s generic
+     * `toCDN()` fallback for a non-text-string key. Returns `undefined` to use
+     * that default. The base class implements no such override; a subclass
+     * that carries an alternate key spelling for a non-text key (e.g. a CDDL
+     * e-ref annotated integer key — see `extensions/eref.ts`) overrides this
+     * instead of `CborMap` special-casing that subclass directly. Takes the
+     * full `ToJSOptions` (unlike `_toCDN`'s options) since a key-naming choice
+     * like e-ref's `eRefKeys` is a `toJS()`-only concept with no CDN analogue.
+     */
+    _jsObjectKey(_options: ToJSOptions | undefined): string | undefined;
     /** Serialize this node to CBOR binary. */
     toCBOR(options?: ToCBOROptions): Uint8Array;
     /** Serialize this node to a CDN text string. */

package/dist/ast/CborTag.d.ts

@@ -13,6 +13,14 @@ export declare class CborTag extends CborItem {
      * (`0x3e7`, decimal, …) when `preserveNumberFormat` is set.
      */
     ednSource?: string;
+    /**
+     * Set by `cddl`-validated decoding/parsing/conversion when the schema
+     * itself implies this tag at its position (see `cddl/implicitTags.ts`),
+     * so `toJS()` can leave it off the JS value — see
+     * `ToJSOptions.implicitTags`.
+     * @internal
+     */
+    _implicit: boolean;
     constructor(tag: number | bigint, content: CborItem, options?: {
         encodingWidth?: EncodingWidth;
         ednSource?: string;
@@ -47,6 +55,20 @@ export declare class CborTag extends CborItem {
     _isMultiWordText(options: ToCDNOptions | undefined, strict?: boolean, path?: readonly unknown[]): boolean;
     _encodeTo(writer: CborWriter, options?: ToCBOROptions): void;
     _toCDN(options: ToCDNOptions | undefined, depth: number, path?: readonly unknown[]): string;
+    /**
+     * The hex-dump comment for this tag's head: `Tag N`, followed by an
+     * RFC 9277 label when there is one — `Tag 55799 (self-described CBOR)`,
+     * `Tag 1668546929 (CoAP Content-Format 112)`, `Tag 1330664270 ("OPSN")`
+     * for a protocol-specific tag spelling four printable ASCII characters.
+     */
+    hexDumpComment(): string;
     _toHexDump(depth: number, options?: ToCDNOptions): AnnotatedLine[];
     _toJS(options?: ToJSOptions, path?: readonly unknown[], occurrence?: Occurrence): unknown;
+    /**
+     * Attach this tag to the converted content `value` — unless `stripTags`,
+     * or the tag is schema-implied (`_implicit`) and `implicitTags` isn't
+     * `false`.
+     * @internal
+     */
+    _tagJS(value: unknown, options?: ToJSOptions): unknown;
 }

package/dist/ast/CborUnresolvedAppExt.d.ts

@@ -12,5 +12,14 @@ export declare const CPA999_TAG = 999n;
  */
 export declare class CborUnresolvedAppExt extends CborTag {
     constructor(prefix: string, items: CborItem[]);
+    /** App-string form (`prefix'text'`), as opposed to an app-sequence. */
+    private get _isAppString();
+    /**
+     * An app-string (`e'alg'`) renders as a plain literal, not the
+     * `[prefix, text]` array it wraps, so it's a leaf for
+     * `inlineLeafContainers` — word-counted like a text string instead (via
+     * `CborTag._isMultiWordText`'s tokenizing of the rendered output).
+     */
+    get _containsCdnContainer(): boolean;
     _toCDN(options: ToCDNOptions | undefined, depth: number): string;
 }

package/dist/ast/index.cjs

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

package/dist/ast/index.js

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

package/dist/cbor/tagLabels.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Human-readable labels for tag numbers defined by RFC 9277 (On Stable
+ * Storage for Items in CBOR), used to annotate `Tag N` hex-dump comments.
+ */
+/**
+ * Inverse of RFC 9277 Appendix B's `TN(ct) = 0x63740101 + (ct / 255) *
+ * 256 + ct % 255`: returns the CoAP Content-Format number `tag` stands for, or
+ * `undefined` when `tag` isn't in that range. The mapping never produces a
+ * zero byte, so a tag with a zero in either of its low two bytes isn't one.
+ */
+export declare function coapContentFormatOfTag(tag: bigint): number | undefined;
+/**
+ * The four ASCII characters spelled by a protocol-specific tag number
+ * (RFC 9277 §2.1 encourages a mnemonic of four ASCII codes, e.g.
+ * `1330664270` = `0x4F50534E` = `"OPSN"`), or `undefined` when `tag` is
+ * outside `0x01000000`..`0xFFFFFFFF` or any byte isn't printable ASCII
+ * (`0x20`..`0x7E`).
+ */
+export declare function asciiMnemonicOfTag(tag: bigint): string | undefined;
+/**
+ * RFC 9277 label for `tag`, for a hex-dump comment — `self-described CBOR`,
+ * `CoAP Content-Format 112`, `"OPSN"` — or `undefined` when there's none.
+ * The CoAP range is checked before the ASCII mnemonic: it is a specific
+ * allocation, and its `"ct"` prefix would otherwise read as a mnemonic.
+ */
+export declare function rfc9277TagLabel(tag: bigint): string | undefined;

package/dist/cddl/eRefScope.d.ts

@@ -0,0 +1,241 @@
+import { CddlSchema } from './schema';
+import { CddlGroupEntry, CddlMemberKey, CddlType, CddlType1 } from './ast';
+import { CborItem } from '../ast/CborItem';
+import { ValidateOptions } from './validator';
+/**
+ * The CDDL type governing one position in a JS value tree — opaque outside
+ * this module; obtain one via `resolveRootScope()`, then `resolveNestedScope()`
+ * for each property that itself holds a nested object.
+ */
+export interface ERefScope {
+    /**
+     * Every distinct alternative shape this position's type could resolve
+     * to — one array per `/`/`//` choice alternative (including every
+     * `/=`/`//=` extension of the rule), each holding *that* alternative's
+     * own complete group entries. Kept separate, not merged into one flat
+     * list, so `scopeNameToValue()` can tell "this name means the same thing
+     * in every alternative that mentions it, and isn't plain text in any of
+     * them" (safe) apart from "different alternatives disagree about it"
+     * (unsafe) — see the module doc.
+     */
+    readonly alternatives: readonly (readonly CddlGroupEntry[])[];
+}
+/**
+ * The scope for the schema's own root rule (or `ruleName`, matching
+ * `ValidateOptions.rule` — `fromJS()`'s own eRefKeys resolution should
+ * start from the same rule the caller will actually validate against).
+ * `undefined` when the named rule doesn't exist, isn't a map type, or
+ * can't be resolved this way at all — see the module doc's Scope note.
+ */
+export declare function resolveRootScope(schema: CddlSchema, ruleName?: string): ERefScope | undefined;
+/**
+ * The CDDL type governing an *array* position — the counterpart of
+ * `ERefScope` for a value that is a `CborArray`/JS array rather than a
+ * map/object. One positional element-type list per array alternative this
+ * position's type could resolve to (kept separate, the same way
+ * `ERefScope.alternatives` is). Only produced for arrays whose every entry
+ * is exactly one element (no `?`/`*`/`+`), so element *i* of an array of
+ * length *n* is governed by entry *i* of every alternative of length *n* —
+ * no matching against the data required. An alternative of a different
+ * length simply can't be the one the data matched, so it's skipped
+ * (`resolveElementPosition()`).
+ */
+export interface ERefArrayScope {
+    readonly elementTypes: readonly (readonly CddlType[])[];
+}
+/**
+ * Everything known about one position in the value tree: its scope if the
+ * value there is a map (`map`), and its positional element types if it's an
+ * array (`array`). Both may be set when the governing type is a `/` choice
+ * between a map and an array; the walker uses whichever matches the value
+ * actually found there.
+ */
+export interface ERefPosition {
+    readonly map?: ERefScope;
+    readonly array?: ERefArrayScope;
+}
+/** A position nothing is known about — no names apply anywhere below it. */
+export declare const NO_POSITION: ERefPosition;
+/**
+ * `resolveRootScope()`'s own counterpart covering an array root too —
+ * e.g. `COSE_Sign1 = [protected: …, unprotected: header_map, …]`.
+ */
+export declare function resolveRootPosition(schema: CddlSchema, ruleName?: string): ERefPosition;
+/**
+ * `resolveNestedScope()`'s own counterpart covering an array value too —
+ * the position of `identifier`'s own value within map scope `scope`.
+ */
+export declare function resolveNestedPosition(schema: CddlSchema, scope: ERefScope, identifier: string | bigint, respectDeclarationOrder?: boolean): ERefPosition;
+/**
+ * The position of element `index` within an array of `length` elements
+ * governed by `arrayScope` — the union of entry `index`'s own type across
+ * every alternative of exactly that length (see `ERefArrayScope`'s own
+ * doc). `NO_POSITION` when no alternative has that length.
+ */
+export declare function resolveElementPosition(schema: CddlSchema, arrayScope: ERefArrayScope, index: number, length: number): ERefPosition;
+/**
+ * The e-ref name a member key gives the integer key `keyValue` it
+ * consumed — the member's own `&(name: value)` binding for that value (from
+ * a fully literal enum group, the only kind that pins the key down to one
+ * named value), or a bare reference to a constant rule with that value.
+ * `undefined` for any other member key (a bareword/literal key, a wildcard,
+ * a controlled or non-literal key), or when the reference is a generic
+ * parameter (`paramBound`), which names no rule at all.
+ */
+export declare function memberKeyName(schema: CddlSchema, mk: CddlMemberKey, keyValue: bigint, paramBound: (name: string) => boolean): string | undefined;
+/** A type that is just a reference to rule `name` (the validation root). */
+export declare function ruleRefType(name: string): CddlType;
+/**
+ * `type`'s own fixed-shape array alternatives (see `ERefArrayScope`), or
+ * `undefined` when it may be an array of some other shape.
+ */
+export declare function arrayScopeOfType(schema: CddlSchema, type: CddlType): ERefArrayScope | undefined;
+/**
+ * The array alternatives in `arrayScope` a decoded array's `items`
+ * actually satisfy — same length, and every element matching its own
+ * entry's type. An element whose check runs out of budget keeps its
+ * alternative (including an extra alternative only ever makes annotation
+ * more conservative, never wrong).
+ */
+export declare function matchingArrayAlternatives(schema: CddlSchema, arrayScope: ERefArrayScope, items: readonly CborItem[], options?: ValidateOptions): ERefArrayScope;
+/**
+ * `type`'s own `/` alternatives with parentheses and (non-generic) type-rule
+ * references expanded in place — including every `/=` extension of a
+ * referenced rule — so each result is a `type1` that is neither of those.
+ * A controlled alternative (`bstr .cbor T`) is kept whole, never looked
+ * into. `undefined` when some alternative can't be expanded this way (a
+ * generic reference, a rule defined nowhere, or a group rule referenced as
+ * a type). A reference cycle contributes no alternatives of its own.
+ */
+export declare function typeAlternatives(schema: CddlSchema, type: CddlType, seen?: ReadonlySet<string>): CddlType1[] | undefined;
+/** One `CddlType` whose alternatives are all of `types`' own, combined. */
+export declare function mergeTypes(types: readonly CddlType[]): CddlType;
+/**
+ * Name → value, from every `&(name: value)`/bare-constant-reference entry
+ * directly at a member-key position among `scope`'s own alternatives (not
+ * entries nested inside a further nested map) — the names `fromJS()` may
+ * convert *this* object's own direct property names against.
+ *
+ * A name is included only when it's *consistently* eRefKeys-eligible
+ * across every one of `scope`'s own alternatives: excluded entirely if
+ * *any* alternative uses it as a plain bareword/quoted-text member key
+ * (that alternative wants a literal text key there, and which alternative
+ * the JS value being converted actually corresponds to isn't known without
+ * validating it — something this module doesn't attempt), and excluded if
+ * the alternatives that *do* bind it via `&(name: value)`/a bare
+ * constant-rule reference disagree on the value. An alternative that
+ * doesn't mention the name at all is simply silent on it, not a conflict.
+ *
+ * A `&(name: value)` binding's own value is computed fresh per scope —
+ * unlike a bare reference to a constant rule (`? group_mode => bool`),
+ * whose value comes from the rule's own, genuinely schema-wide definition,
+ * so it's looked up via `getERefTables(schema).ruleConstantValues` — never
+ * plain `byName`, which also mixes in any `&(name: value)` enum *label*
+ * bound to `name` elsewhere in the schema (irrelevant here: a bare type
+ * reference names a *rule*, not "this spelling however it's used
+ * anywhere" — see `ruleConstantValues`'s own doc).
+ *
+ * This *value* is safe to use positionally as-is — it's exactly the
+ * integer this position's own schema names, independent of anything
+ * elsewhere in the document. Whether the resulting key should also be
+ * *labeled* `e'name'` is a separate question `resolvesGloballyTo()`
+ * answers — see its own doc for why.
+ *
+ * `respectDeclarationOrder` (default `true`) controls whether a name
+ * declared before a same-alternative wildcard is included per that
+ * relaxation — see the module doc's own note on why `fromJS()` must pass
+ * `false` here instead, falling back to the plain "any open entry anywhere
+ * in this alternative excludes every name in it" behavior.
+ */
+export declare function scopeNameToValue(schema: CddlSchema, scope: ERefScope, respectDeclarationOrder?: boolean): ReadonlyMap<string, bigint>;
+/**
+ * Whether `name` labeling `value` here would also resolve the *same* way
+ * through `parseAppString()` (`e'name'`'s own parse direction), which
+ * consults `getERefTables(schema).byName` — a single, genuinely
+ * schema-wide table, unlike `scopeNameToValue()`'s own position-scoped
+ * one. A name can be locally unambiguous at one member-key position (safe
+ * to use as *this* key's integer value — see `scopeNameToValue()`) while
+ * being bound to a *different* value, or ambiguously to more than one, at
+ * some other, unrelated member-key position elsewhere in the same schema.
+ * Labeling the key `e'name'` in that case would round-trip incorrectly (or
+ * not at all) through `fromCDN()` against the very same schema, so
+ * `fromJS()` only does so when this returns `true` — otherwise the key
+ * still gets the correct integer value, just as a plain, unlabeled
+ * integer (see `js/fromJS.ts`'s own use of this).
+ */
+export declare function resolvesGloballyTo(schema: CddlSchema, name: string, value: bigint): boolean;
+/**
+ * `scopeNameToValue()`'s own result, inverted — dropping any value bound to
+ * more than one *different* name at this position, since picking either
+ * would be an arbitrary, unjustified choice this position's own schema
+ * doesn't actually make (each individual name is still unambiguous on its
+ * own — see `scopeNameToValue()`'s own doc — this is only about two
+ * *different* names colliding on the same value). Used wherever a caller
+ * already has an integer *value* (not a name) — e.g. an already-decoded map
+ * key, or a `MapEntries` entry whose key is a plain number rather than a
+ * string — and needs to know which name, if any, unambiguously describes
+ * it at this position, so it can resolve a nested scope for that entry's
+ * own value the same way a literal string key's name would (see
+ * `extensions/eref.ts` and `js/fromJS.ts`'s own uses).
+ */
+export declare function scopeValueToName(schema: CddlSchema, scope: ERefScope): ReadonlyMap<bigint, string>;
+/**
+ * The scope for `identifier`'s own nested value — matching, across every
+ * one of `scope`'s own alternatives, an entry whose member key is either a
+ * literal bareword/quoted-text key equal to `identifier` (a `string`), the
+ * `&(name: value)`/bare-reference entry that names it (only when
+ * `identifier` is itself one of `scope`'s own `scopeNameToValue()` names),
+ * *or* a differently-spelled member key that resolves to that exact same
+ * integer value — e.g. a literal `1: …` entry in one alternative and
+ * `&(data: 1) => …` in another both govern the same wire position, even
+ * though only the second one *names* it. Passing `identifier` as a
+ * `bigint` instead skips name resolution entirely and matches purely by
+ * that integer value — for a wire key with no name of its own at all, e.g.
+ * a literal `1: &(AES-CCM-16-64-128: 10)` entry, whose value can still be
+ * resolved this way even though the key `1` itself was never eRefKeys
+ * -eligible (see `extensions/eref.ts`'s own use of this for exactly this
+ * case). Every matching entry's own value type is resolved into the
+ * nested scope's own alternatives (kept separate from each other the same
+ * way `scope`'s own were — see the module doc); `undefined` when nothing
+ * matches `identifier` at all, when what matches doesn't resolve to a map
+ * type anywhere, or when an open/wildcard member key (`firstOpenIndex()`)
+ * at or before the matching entry, *within that same alternative*, could
+ * equally claim the same wire key with a shape this resolver can't pin
+ * down — see `firstOpenIndex()`'s own doc for exactly when that does and
+ * doesn't apply. The object being converted might just as well belong to
+ * that open entry instead of whichever named one matched literally, so
+ * descending as if it definitely doesn't would risk exactly the same
+ * "wrong alternative" misconversion `scopeNameToValue()`'s own doc
+ * describes for `scope`'s own direct names.
+ *
+ * `respectDeclarationOrder` (default `true`) — see `scopeNameToValue()`'s
+ * own doc; `fromJS()` passes `false` when descending from a JS property
+ * name it hasn't (or can't) also convert to an integer key this same way,
+ * so the nested scope it resolves stays consistent with that decision.
+ */
+export declare function resolveNestedScope(schema: CddlSchema, scope: ERefScope, identifier: string | bigint, respectDeclarationOrder?: boolean): ERefScope | undefined;
+/**
+ * The name safely labeling `value` when it's the value of `identifier`'s
+ * own entry within `scope` — resolving that entry's own value type
+ * (`matchingValueType()`, the same position-aware matching
+ * `resolveNestedScope()` uses) via `resolveEnumNames()`. Symmetric with
+ * `resolveNestedScope()`, but for a value whose *type* is (or resolves to)
+ * a closed `&(name: value)` choice of named integer constants — e.g.
+ * `? &(gp_enc_alg: -4) => &(AES-CCM-16-64-128: 10, …)` — rather than a
+ * nested map. `identifier` may be a `bigint` to match purely by the key's
+ * own value when it has no name of its own at all (see
+ * `resolveNestedScope()`'s own doc). `undefined` when no matching entry's
+ * value type names `value` this way, when any matching entry's value type
+ * can't be confidently resolved (see `resolveEnumNames()`'s own doc), or
+ * when `scope` has an open/wildcard member key. Always uses the relaxed,
+ * declaration-order-aware matching (see `scopeNameToValue()`'s own doc) —
+ * every caller is on the annotation side, resolving an already-decoded
+ * wire value, never `fromJS()`'s own forward conversion.
+ */
+export declare function resolveValueEnumName(schema: CddlSchema, scope: ERefScope, identifier: string | bigint, value: bigint): string | undefined;
+/**
+ * The name `type` — a value's own type, e.g. the merged types of the members that consumed it —
+ * safely gives integer `value`: resolved via `resolveEnumNames()`, so any
+ * choice accepting the same integer under no name blocks it.
+ */
+export declare function enumNameOfType(schema: CddlSchema, type: CddlType, value: bigint): string | undefined;

package/dist/cddl/eref.d.ts

@@ -0,0 +1,64 @@
+import { CddlSchema } from './schema';
+import { CddlType } from './ast';
+export interface ERefTables {
+    /** Name → value, for resolving `e'name'` while parsing CDN. */
+    readonly byName: ReadonlyMap<string, bigint>;
+    /**
+     * Value → name, for annotating a validated integer map key with a name —
+     * populated only from a binding at a genuine map-member-key position
+     * (a `&(name: value)` literal, or a bare reference to a constant rule
+     * used as the member key itself — never from either construct appearing
+     * anywhere else, and never from a general constant rule that isn't
+     * referenced at a member-key position at all) and only when neither the
+     * name nor the value is ambiguous (see the module doc and
+     * `ambiguousNames`).
+     */
+    readonly byValue: ReadonlyMap<bigint, string>;
+    /**
+     * Name → value, the exact inverse of `byValue` (safe and unambiguous by
+     * construction: every name appearing in `byValue` appears there with
+     * exactly one value, since a name bound to more than one value is already
+     * excluded — see `ambiguousNames`). Used for the reverse direction:
+     * `fromJS()`'s `eRefKeys` option converting a plain-object property name
+     * back to the integer key it names, symmetric with `ToJSOptions.eRefKeys`.
+     */
+    readonly nameToValue: ReadonlyMap<string, bigint>;
+    /**
+     * Names that were seen bound to more than one different value anywhere in
+     * the schema, and so were excluded from `byName` (and, transitively, from
+     * every `byValue`/`nameToValue` entry that would have named a value after
+     * one of them) — kept separately only to produce a clearer "ambiguous"
+     * error message than a plain "not defined" one would.
+     */
+    readonly ambiguousNames: ReadonlySet<string>;
+    /**
+     * Name → value, from `name = <int literal>` rule definitions **only**
+     * (including every `/=`/`//=` extension of the same name, when they all
+     * agree on a single value) — deliberately excludes a name that's *only*
+     * ever used as an `&(name: value)` enum label somewhere in the schema,
+     * even though that label also feeds `byName`/`nameToValue` (a
+     * general-purpose lookup that doesn't distinguish the two, correctly, for
+     * `e'name'`'s own CDN parse direction). A *bare* type reference at a
+     * member-key position (`? group_mode => bool`, or a wildcard's own key
+     * type, `* group_mode => …`) means "this rule's own constant value" —
+     * e.g. `group_mode = 3` — never "this spelling, however it's used
+     * anywhere in the schema"; conflating the two would let an unrelated
+     * `&(group_mode: 2) => …` enum label elsewhere make a wildcard whose key
+     * type is the *rule* `group_mode` (which might not even be an integer
+     * type at all) look like a closed, safe reference when it isn't — see
+     * `cddl/eRefScope.ts`'s own use of this.
+     */
+    readonly ruleConstantValues: ReadonlyMap<string, bigint>;
+}
+/**
+ * Extract (and cache, per schema instance) the `e'...'` name tables for a
+ * compiled CDDL schema.
+ */
+export declare function getERefTables(schema: CddlSchema): ERefTables;
+/**
+ * The literal integer value of a `type`, when it reduces to a single
+ * `type1` alternative with no range/control operator. `undefined` for
+ * anything else. Exported for `eRefScope.ts`'s own, position-aware name
+ * extraction, which needs the exact same check for an entry's own value.
+ */
+export declare function literalIntOfType(type: CddlType): bigint | undefined;

package/dist/cddl/implicitTags.d.ts

@@ -0,0 +1,28 @@
+import { CddlSchema } from './schema';
+import { TagRecord, ValidateOptions } from './validator';
+import { CborItem } from '../ast/CborItem';
+/**
+ * `item` with every tag the schema implies — but that the item lacks —
+ * added via `makeTag`, when that is what makes it valid. Returns `item`
+ * itself (unchanged) when it already validates, or when even inference
+ * cannot make it valid (the caller's own validation then reports why).
+ * Nodes are replaced in place inside their containers; the returned root
+ * differs from `item` only when the root itself gets tagged.
+ */
+export declare function inferImplicitTags(schema: CddlSchema, item: CborItem, options: ValidateOptions | undefined, makeTag: (tag: bigint, inner: CborItem) => CborItem): CborItem;
+/**
+ * Flag (`CborTag._implicit`) every tag in `item` that the schema implies
+ * and that `inferImplicitTags()` would restore exactly if it were left off;
+ * clear the flag on every other tag. `trail` holds the records of the
+ * caller's own successful validation of `item` (its candidates: every tag
+ * matched by a literal `#6.N`).
+ *
+ * The candidate set shrinks until stripping it and inferring again yields
+ * back exactly that set: a tag that isn't restored (another alternative
+ * accepts the untagged content, the untagged tree already validates, …)
+ * drops out, and dropping one can change what the rest infer, hence the
+ * rounds. If inference would ever tag something that wasn't tagged, or
+ * the rounds run out, nothing is flagged — omission is an optimization,
+ * never worth a round trip that changes the data.
+ */
+export declare function markImplicitTags(schema: CddlSchema, item: CborItem, options: ValidateOptions | undefined, trail: readonly TagRecord[]): void;

package/dist/cddl/index.cjs

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

package/dist/cddl/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/cddl/position.ts","../../src/cddl/index.ts"],"sourcesContent":["/**\n * Convert a character offset (as carried by CDDL AST nodes, CddlWarning,\n * and CddlValidationError.schemaStart/schemaEnd or start/end for CDN input)\n * into a 1-based line/column position, for CLI-style `file:line:col`\n * reporting.\n *\n * Offsets are JS string indices (UTF-16 code units), matching everything\n * else in this library. Offsets past the end of the text clamp to its end.\n */\nexport function positionAt(\n  text: string,\n  offset: number\n): { line: number; column: number } {\n  const end = Math.max(0, Math.min(offset, text.length));\n  let line = 1;\n  let lineStart = 0;\n  for (let i = 0; i < end; i++) {\n    if (text.charCodeAt(i) === 0x0a) {\n      line++;\n      lineStart = i + 1;\n    }\n  }\n  return { line, column: end - lineStart + 1 };\n}\n","/**\n * Public CDDL API (`@cbortech/cbor/cddl`).\n *\n * Phase 1 covers the grammar layer of RFC 8610 + RFC 9682: compiling CDDL\n * text into a checked rule table (`CDDL.compile`), re-serializing it\n * (`schema.format()`), and the lower-level tokenization API used by tooling\n * such as syntax highlighters. Validating CBOR/CDN data against a schema is\n * a later phase.\n */\n\nimport { CddlTokenizer, type CddlComment, type CddlToken } from './tokenizer';\nimport { CddlSyntaxError } from './errors';\nimport { compile, CddlSchema, type CompileOptions } from './schema';\n\nexport type { CddlToken, CddlTokenType, CddlComment } from './tokenizer';\nexport {\n  CddlSyntaxError,\n  CddlSemanticError,\n  CddlMismatchError,\n} from './errors';\nexport type {\n  CddlWarning,\n  CddlValidationError,\n  CddlValidationWarning,\n  ValidationResult,\n} from './errors';\nexport type { ValidateOptions } from './validator';\nexport { CddlSchema } from './schema';\nexport type { CompileOptions } from './schema';\nexport { parseCDDL } from './parser';\nexport type { ParseCddlResult } from './parser';\nexport { PRELUDE_CDDL, getPreludeRules } from './prelude';\nexport { positionAt } from './position';\nexport type { CddlFormatOptions } from './writer';\nexport type {\n  CddlRule,\n  CddlType,\n  CddlType1,\n  CddlType2,\n  CddlValue,\n  CddlRef,\n  CddlParenType,\n  CddlMapType,\n  CddlArrayType,\n  CddlUnwrap,\n  CddlEnum,\n  CddlTagged,\n  CddlMajor,\n  CddlAny,\n  CddlGroup,\n  CddlGroupEntry,\n  CddlEntryValue,\n  CddlEntryGroup,\n  CddlOccur,\n  CddlMemberKey,\n  CddlNodeBase,\n} from './ast';\n\n/** Main CDDL facade — mirrors the shape of the `CBOR` facade. */\nexport class CDDL {\n  /**\n   * Parse and compile a CDDL data model.\n   *\n   * @example\n   * const schema = CDDL.compile(`person = { name: tstr, ? age: uint }`);\n   * schema.root.name;  // 'person'\n   */\n  static compile(text: string, options?: CompileOptions): CddlSchema {\n    return compile(text, options);\n  }\n}\n\nexport default CDDL;\n\nexport interface TokenizeResult {\n  /** Scanned tokens in source order, excluding the final EOF token. */\n  tokens: CddlToken[];\n  /** Comments encountered while scanning, in source order. */\n  comments: CddlComment[];\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?: CddlSyntaxError;\n}\n\n/**\n * Tokenize CDDL text. Throws {@link CddlSyntaxError} on invalid input.\n */\nexport function tokenize(text: string): TokenizeResult {\n  const tokenizer = new CddlTokenizer(text);\n  const tokens: CddlToken[] = [];\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 CddlTokenizer(text);\n  const tokens: CddlToken[] = [];\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 CddlSyntaxError\n        ? e\n        : new CddlSyntaxError(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":"yIASA,SAAgB,EACd,EACA,EACkC,CAClC,IAAM,EAAM,KAAK,IAAI,EAAG,KAAK,IAAI,EAAQ,EAAK,MAAM,CAAC,EACjD,EAAO,EACP,EAAY,EAChB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,IACnB,EAAK,WAAW,CAAC,IAAM,KACzB,IACA,EAAY,EAAI,GAGpB,MAAO,CAAE,OAAM,OAAQ,EAAM,EAAY,CAAE,CAC7C,CCoCA,IAAa,EAAb,KAAkB,CAQhB,OAAO,QAAQ,EAAc,EAAsC,CACjE,OAAO,EAAA,EAAQ,EAAM,CAAO,CAC9B,CACF,EAuBA,SAAgB,EAAS,EAA8B,CACrD,IAAM,EAAY,IAAI,EAAA,EAAc,CAAI,EAClC,EAAsB,CAAC,EAC7B,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,EAAc,CAAI,EAClC,EAAsB,CAAC,EAC7B,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,EAAgB,aAAa,MAAQ,EAAE,QAAU,OAAO,CAAC,CAAC,EAC9D,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/cddl/position.ts","../../src/cddl/index.ts"],"sourcesContent":["/**\n * Convert a character offset (as carried by CDDL AST nodes, CddlWarning,\n * and CddlValidationError.schemaStart/schemaEnd or start/end for CDN input)\n * into a 1-based line/column position, for CLI-style `file:line:col`\n * reporting.\n *\n * Offsets are JS string indices (UTF-16 code units), matching everything\n * else in this library. Offsets past the end of the text clamp to its end.\n */\nexport function positionAt(\n  text: string,\n  offset: number\n): { line: number; column: number } {\n  const end = Math.max(0, Math.min(offset, text.length));\n  let line = 1;\n  let lineStart = 0;\n  for (let i = 0; i < end; i++) {\n    if (text.charCodeAt(i) === 0x0a) {\n      line++;\n      lineStart = i + 1;\n    }\n  }\n  return { line, column: end - lineStart + 1 };\n}\n","/**\n * Public CDDL API (`@cbortech/cbor/cddl`).\n *\n * Phase 1 covers the grammar layer of RFC 8610 + RFC 9682: compiling CDDL\n * text into a checked rule table (`CDDL.compile`), re-serializing it\n * (`schema.format()`), and the lower-level tokenization API used by tooling\n * such as syntax highlighters. Validating CBOR/CDN data against a schema is\n * a later phase.\n */\n\nimport { CddlTokenizer, type CddlComment, type CddlToken } from './tokenizer';\nimport { CddlSyntaxError } from './errors';\nimport { compile, CddlSchema, type CompileOptions } from './schema';\n\nexport type { CddlToken, CddlTokenType, CddlComment } from './tokenizer';\nexport {\n  CddlSyntaxError,\n  CddlSemanticError,\n  CddlMismatchError,\n} from './errors';\nexport type {\n  CddlWarning,\n  CddlValidationError,\n  CddlValidationWarning,\n  ValidationResult,\n} from './errors';\nexport type { ValidateOptions } from './validator';\nexport { CddlSchema } from './schema';\nexport type { CompileOptions } from './schema';\nexport { parseCDDL } from './parser';\nexport type { ParseCddlResult } from './parser';\nexport { PRELUDE_CDDL, getPreludeRules } from './prelude';\nexport { getERefTables } from './eref';\nexport type { ERefTables } from './eref';\nexport { positionAt } from './position';\nexport type { CddlFormatOptions } from './writer';\nexport type {\n  CddlRule,\n  CddlType,\n  CddlType1,\n  CddlType2,\n  CddlValue,\n  CddlRef,\n  CddlParenType,\n  CddlMapType,\n  CddlArrayType,\n  CddlUnwrap,\n  CddlEnum,\n  CddlTagged,\n  CddlMajor,\n  CddlAny,\n  CddlGroup,\n  CddlGroupEntry,\n  CddlEntryValue,\n  CddlEntryGroup,\n  CddlOccur,\n  CddlMemberKey,\n  CddlNodeBase,\n} from './ast';\n\n/** Main CDDL facade — mirrors the shape of the `CBOR` facade. */\nexport class CDDL {\n  /**\n   * Parse and compile a CDDL data model.\n   *\n   * @example\n   * const schema = CDDL.compile(`person = { name: tstr, ? age: uint }`);\n   * schema.root.name;  // 'person'\n   */\n  static compile(text: string, options?: CompileOptions): CddlSchema {\n    return compile(text, options);\n  }\n}\n\nexport default CDDL;\n\nexport interface TokenizeResult {\n  /** Scanned tokens in source order, excluding the final EOF token. */\n  tokens: CddlToken[];\n  /** Comments encountered while scanning, in source order. */\n  comments: CddlComment[];\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?: CddlSyntaxError;\n}\n\n/**\n * Tokenize CDDL text. Throws {@link CddlSyntaxError} on invalid input.\n */\nexport function tokenize(text: string): TokenizeResult {\n  const tokenizer = new CddlTokenizer(text);\n  const tokens: CddlToken[] = [];\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 CddlTokenizer(text);\n  const tokens: CddlToken[] = [];\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 CddlSyntaxError\n        ? e\n        : new CddlSyntaxError(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":"iLASA,SAAgB,EACd,EACA,EACkC,CAClC,IAAM,EAAM,KAAK,IAAI,EAAG,KAAK,IAAI,EAAQ,EAAK,MAAM,CAAC,EACjD,EAAO,EACP,EAAY,EAChB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,IACnB,EAAK,WAAW,CAAC,IAAM,KACzB,IACA,EAAY,EAAI,GAGpB,MAAO,CAAE,OAAM,OAAQ,EAAM,EAAY,CAAE,CAC7C,CCsCA,IAAa,EAAb,KAAkB,CAQhB,OAAO,QAAQ,EAAc,EAAsC,CACjE,OAAO,EAAA,EAAQ,EAAM,CAAO,CAC9B,CACF,EAuBA,SAAgB,EAAS,EAA8B,CACrD,IAAM,EAAY,IAAI,EAAA,EAAc,CAAI,EAClC,EAAsB,CAAC,EAC7B,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,EAAc,CAAI,EAClC,EAAsB,CAAC,EAC7B,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,EAAgB,aAAa,MAAQ,EAAE,QAAU,OAAO,CAAC,CAAC,EAC9D,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/cddl/index.d.ts

@@ -10,6 +10,8 @@ export type { CompileOptions } from './schema';
 export { parseCDDL } from './parser';
 export type { ParseCddlResult } from './parser';
 export { PRELUDE_CDDL, getPreludeRules } from './prelude';
+export { getERefTables } from './eref';
+export type { ERefTables } from './eref';
 export { positionAt } from './position';
 export type { CddlFormatOptions } from './writer';
 export type { CddlRule, CddlType, CddlType1, CddlType2, CddlValue, CddlRef, CddlParenType, CddlMapType, CddlArrayType, CddlUnwrap, CddlEnum, CddlTagged, CddlMajor, CddlAny, CddlGroup, CddlGroupEntry, CddlEntryValue, CddlEntryGroup, CddlOccur, CddlMemberKey, CddlNodeBase, } from './ast';