@cbortech/cbor 0.27.0 → 0.27.2

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-iXpYtKQl.cjs");function t(e,t){let n=Math.max(0,Math.min(t,e.length)),r=1,i=0;for(let t=0;t<n;t++)e.charCodeAt(t)===10&&(r++,i=t+1);return{line:r,column:n-i+1}}var n=class{static compile(t,n){return e.n(t,n)}};function r(t){let n=new e.o(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function i(t){let n=new e.o(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.l?i:new e.l(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
-`?(e++,n=1):n++;r.push({type:`ERROR`,value:t.slice(o),raw:t.slice(o),line:e,col:n,offset:o,endOffset:t.length})}return{tokens:r,comments:n.comments,error:a}}}exports.CDDL=n,exports.default=n,exports.CddlMismatchError=e.s,exports.CddlSchema=e.t,exports.CddlSemanticError=e.c,exports.CddlSyntaxError=e.l,exports.PRELUDE_CDDL=e.r,exports.getPreludeRules=e.i,exports.parseCDDL=e.a,exports.positionAt=t,exports.tokenize=r,exports.tokenizeLenient=i;
+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';

package/dist/cddl/index.js

@@ -1,6 +1,7 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "../schema-CNfrVRYp.js";
+import { $ as e, Q as t, Z as n, d as r, f as i, m as a, p as o, u as s } from "../mapEntries-8zshEr-t.js";
+import { n as c, t as l } from "../schema-7r2xjpMK.js";
 //#region src/cddl/position.ts
-function l(e, t) {
+function u(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 {
@@ -10,13 +11,13 @@ function l(e, t) {
 }
 //#endregion
 //#region src/cddl/index.ts
-var u = class {
+var d = class {
 	static compile(e, t) {
-		return i(e, t);
+		return c(e, t);
 	}
 };
-function d(e) {
-	let t = new a(e), n = [];
+function f(e) {
+	let t = new o(e), n = [];
 	for (;;) {
 		let e = t.consume();
 		if (e.type === "EOF") break;
@@ -27,41 +28,41 @@ function d(e) {
 		comments: t.comments
 	};
 }
-function f(e) {
-	let t = new a(e), n = [];
+function p(t) {
+	let n = new o(t), r = [];
 	try {
 		for (;;) {
-			let e = t.consume();
+			let e = n.consume();
 			if (e.type === "EOF") break;
-			n.push(e);
+			r.push(e);
 		}
 		return {
-			tokens: n,
-			comments: t.comments
+			tokens: r,
+			comments: n.comments
 		};
 	} catch (i) {
-		let a = i instanceof r ? i : new r(i instanceof Error ? i.message : String(i)), o = t.lastEndOffset;
-		if (o < e.length) {
-			let t = 1, r = 1;
-			for (let n = 0; n < o; n++) e[n] === "\n" ? (t++, r = 1) : r++;
-			n.push({
+		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] === "\n" ? (e++, n = 1) : n++;
+			r.push({
 				type: "ERROR",
-				value: e.slice(o),
-				raw: e.slice(o),
-				line: t,
-				col: r,
+				value: t.slice(o),
+				raw: t.slice(o),
+				line: e,
+				col: n,
 				offset: o,
-				endOffset: e.length
+				endOffset: t.length
 			});
 		}
 		return {
-			tokens: n,
-			comments: t.comments,
+			tokens: r,
+			comments: n.comments,
 			error: a
 		};
 	}
 }
 //#endregion
-export { u as CDDL, u as default, s as CddlMismatchError, c as CddlSchema, t as CddlSemanticError, r as CddlSyntaxError, o as PRELUDE_CDDL, n as getPreludeRules, e as parseCDDL, l as positionAt, d as tokenize, f as tokenizeLenient };
+export { d as CDDL, d as default, n as CddlMismatchError, l as CddlSchema, t as CddlSemanticError, e as CddlSyntaxError, s as PRELUDE_CDDL, a as getERefTables, r as getPreludeRules, i as parseCDDL, u as positionAt, f as tokenize, p as tokenizeLenient };
 
 //# sourceMappingURL=index.js.map

package/dist/cddl/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","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":";;AASA,SAAgB,EACd,GACA,GACkC;CAClC,IAAM,IAAM,KAAK,IAAI,GAAG,KAAK,IAAI,GAAQ,EAAK,MAAM,CAAC,GACjD,IAAO,GACP,IAAY;CAChB,KAAK,IAAI,IAAI,GAAG,IAAI,GAAK,KACvB,AAAI,EAAK,WAAW,CAAC,MAAM,OACzB,KACA,IAAY,IAAI;CAGpB,OAAO;EAAE;EAAM,QAAQ,IAAM,IAAY;CAAE;AAC7C;;;ACoCA,IAAa,IAAb,MAAkB;CAQhB,OAAO,QAAQ,GAAc,GAAsC;EACjE,OAAO,EAAQ,GAAM,CAAO;CAC9B;AACF;AAuBA,SAAgB,EAAS,GAA8B;CACrD,IAAM,IAAY,IAAI,EAAc,CAAI,GAClC,IAAsB,CAAC;CAC7B,SAAS;EACP,IAAM,IAAM,EAAU,QAAQ;EAC9B,IAAI,EAAI,SAAS,OAAO;EACxB,EAAO,KAAK,CAAG;CACjB;CACA,OAAO;EAAE;EAAQ,UAAU,EAAU;CAAS;AAChD;AAQA,SAAgB,EAAgB,GAAqC;CACnE,IAAM,IAAY,IAAI,EAAc,CAAI,GAClC,IAAsB,CAAC;CAC7B,IAAI;EACF,SAAS;GACP,IAAM,IAAM,EAAU,QAAQ;GAC9B,IAAI,EAAI,SAAS,OAAO;GACxB,EAAO,KAAK,CAAG;EACjB;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;EAAS;CAChD,SAAS,GAAG;EACV,IAAM,IACJ,aAAa,IACT,IACA,IAAI,EAAgB,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,CAAC,GAC9D,IAAQ,EAAU;EACxB,IAAI,IAAQ,EAAK,QAAQ;GACvB,IAAI,IAAO,GACP,IAAM;GACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAO,KACzB,AAAI,EAAK,OAAO,QACd,KACA,IAAM,KAEN;GAGJ,EAAO,KAAK;IACV,MAAM;IACN,OAAO,EAAK,MAAM,CAAK;IACvB,KAAK,EAAK,MAAM,CAAK;IACrB;IACA;IACA,QAAQ;IACR,WAAW,EAAK;GAClB,CAAC;EACH;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;GAAU;EAAM;CACvD;AACF"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/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":";;;AASA,SAAgB,EACd,GACA,GACkC;CAClC,IAAM,IAAM,KAAK,IAAI,GAAG,KAAK,IAAI,GAAQ,EAAK,MAAM,CAAC,GACjD,IAAO,GACP,IAAY;CAChB,KAAK,IAAI,IAAI,GAAG,IAAI,GAAK,KACvB,AAAI,EAAK,WAAW,CAAC,MAAM,OACzB,KACA,IAAY,IAAI;CAGpB,OAAO;EAAE;EAAM,QAAQ,IAAM,IAAY;CAAE;AAC7C;;;ACsCA,IAAa,IAAb,MAAkB;CAQhB,OAAO,QAAQ,GAAc,GAAsC;EACjE,OAAO,EAAQ,GAAM,CAAO;CAC9B;AACF;AAuBA,SAAgB,EAAS,GAA8B;CACrD,IAAM,IAAY,IAAI,EAAc,CAAI,GAClC,IAAsB,CAAC;CAC7B,SAAS;EACP,IAAM,IAAM,EAAU,QAAQ;EAC9B,IAAI,EAAI,SAAS,OAAO;EACxB,EAAO,KAAK,CAAG;CACjB;CACA,OAAO;EAAE;EAAQ,UAAU,EAAU;CAAS;AAChD;AAQA,SAAgB,EAAgB,GAAqC;CACnE,IAAM,IAAY,IAAI,EAAc,CAAI,GAClC,IAAsB,CAAC;CAC7B,IAAI;EACF,SAAS;GACP,IAAM,IAAM,EAAU,QAAQ;GAC9B,IAAI,EAAI,SAAS,OAAO;GACxB,EAAO,KAAK,CAAG;EACjB;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;EAAS;CAChD,SAAS,GAAG;EACV,IAAM,IACJ,aAAa,IACT,IACA,IAAI,EAAgB,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,CAAC,GAC9D,IAAQ,EAAU;EACxB,IAAI,IAAQ,EAAK,QAAQ;GACvB,IAAI,IAAO,GACP,IAAM;GACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAO,KACzB,AAAI,EAAK,OAAO,QACd,KACA,IAAM,KAEN;GAGJ,EAAO,KAAK;IACV,MAAM;IACN,OAAO,EAAK,MAAM,CAAK;IACvB,KAAK,EAAK,MAAM,CAAK;IACrB;IACA;IACA,QAAQ;IACR,WAAW,EAAK;GAClB,CAAC;EACH;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;GAAU;EAAM;CACvD;AACF"}

package/dist/cddl/validator.d.ts

@@ -1,7 +1,9 @@
 import { CddlSchema } from './schema';
 import { CborItem } from '../ast/CborItem';
+import { CborMap } from '../ast/CborMap';
+import { CborTag } from '../ast/CborTag';
 import { ValidationResult } from './errors';
-import { CddlValue } from './ast';
+import { CddlGroup, CddlMemberKey, CddlType, CddlType1, CddlValue } from './ast';
 export interface ValidateOptions {
     /** Recursion guard for rule references and nested groups (default 256). */
     maxDepth?: number;
@@ -26,5 +28,99 @@ export interface ValidateOptions {
      */
     rule?: string;
 }
-export declare function validateItem(schema: CddlSchema, item: CborItem, options?: ValidateOptions): ValidationResult;
+/**
+ * One tag on a successful match path: `item` is a `CborTag` matched by a
+ * `#6.N(type)` with literal tag number `tag`, or — `inferred` — an
+ * untagged item that matched only as the content of such a type (see
+ * `TagTracing.infer`).
+ */
+export interface TagRecord {
+    readonly item: CborItem;
+    readonly tag: bigint;
+    readonly inferred: boolean;
+    /**
+     * For an inferred record, how many inferred tags enclose this one around
+     * the same item (0 = outermost): `#6.101(#6.100(int))` records 101 at
+     * layer 0 and 100 at layer 1. Re-checking one layer (`.and`, …) repeats
+     * its layer; a genuinely nested tag, even of the same number, doesn't.
+     * Always 0 for a matched tag.
+     */
+    readonly layer: number;
+}
+/** Tag bookkeeping for {@link validateItem}'s internal callers. */
+export interface TagTracing {
+    /**
+     * Let `#6.N(type)` (literal N) accept an untagged item matching `type`,
+     * recording it as inferred. Only a fallback: at every type, rule and
+     * map-group choice, alternatives are first tried without inference.
+     */
+    readonly infer?: boolean;
+    /** Tags to match as if absent (their content in their place). */
+    readonly stripped?: ReadonlySet<CborTag>;
+    /** Receives the successful path's records (left empty on failure). */
+    readonly trail: TagRecord[];
+}
+/** Generic parameter bindings; each binding closes over its defining env. */
+type Env = Map<string, {
+    type1: CddlType1;
+    env: Env;
+}> | undefined;
+export declare function validateItem(schema: CddlSchema, item: CborItem, options?: ValidateOptions, tags?: TagTracing): ValidationResult;
+/**
+ * Whether `item` matches `type` on its own, exactly as validation would
+ * check it at a position of that type (no generic bindings). `undefined`
+ * when the step/depth budget runs out.
+ */
+export declare function itemMatchesType(schema: CddlSchema, item: CborItem, type: CddlType, options?: ValidateOptions): boolean | undefined;
+/** Opaque generic-parameter bindings in force at some point of a match. */
+export type CddlEnv = Env;
+/**
+ * The group member that consumed one map entry on the validator's own
+ * successful path — its member key, value type, and the generic bindings
+ * in force there.
+ */
+export interface MapMember {
+    readonly memberKey: CddlMemberKey;
+    readonly type: CddlType;
+    readonly env: CddlEnv;
+}
+/** One map group a type can denote, with its generic bindings. */
+export interface MapGroupTarget {
+    readonly group: CddlGroup;
+    readonly env: CddlEnv;
+}
+/**
+ * Every map group (`{...}`) `type` can denote, following references,
+ * parentheses, choices and generic bindings exactly as `matchType()` does.
+ * `undefined` when some alternative could still match a map some *other*
+ * way this can't see into — `any`/`#5`, a control operator, `~unwrap`, an
+ * `&(...)` type, an undefined name — so no single group's assignment is
+ * known to be the one validation used.
+ */
+export declare function mapGroupsOfType(schema: CddlSchema, type: CddlType, env: CddlEnv): MapGroupTarget[] | undefined;
+/**
+ * The literal text a member key requires, when it requires exactly one:
+ * `name:`, `"name":`, or `"name" =>` (a text-literal key type).
+ */
+export declare function plainTextSpelling(mk: CddlMemberKey): string | undefined;
+/**
+ * Every spelling used as a plain text member key anywhere in `target`'s
+ * group — `name:`, `"name":`, or a key type that accepts a text literal
+ * (`"name" =>`, a rule or `/` choice of such literals, or a generic
+ * parameter bound to one, e.g. `K => …` in `G<"name">`) — through inline
+ * sub-groups, bare group references and `~unwrap`ped groups, expanded
+ * exactly as matching expands them (`expandEntry()`), across every choice
+ * and every distinct generic instantiation. `undefined` when the expansion
+ * runs out of budget.
+ */
+export declare function plainTextMemberKeys(schema: CddlSchema, target: MapGroupTarget): ReadonlySet<string> | undefined;
+/**
+ * Match `map` against one map group exactly as validation does
+ * (`matchMapGroup()`), returning which member consumed each of its entries
+ * on the successful path (`false` for one left unconsumed, e.g. an elided
+ * `...` entry). `null` when it doesn't match; `undefined` when the budget
+ * runs out.
+ */
+export declare function traceMapGroup(schema: CddlSchema, map: CborMap, target: MapGroupTarget, options?: ValidateOptions): readonly (MapMember | false)[] | null | undefined;
 export declare function matchesLiteral(item: CborItem, v: CddlValue): boolean;
+export {};

package/dist/cdn/index.cjs

@@ -1,3 +1,3 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../serialize-utils-CjTqQivB.cjs");function t(t){let n=new e.A(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function n(t){let n=new e.A(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.I?i:new e.I(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../serialize-utils-DQ8T3Mzw.cjs");function t(t){let n=new e.A(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function n(t){let n=new e.A(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.I?i:new e.I(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
 `?(e++,n=1):n++;r.push({type:`ERROR`,value:t.slice(o),raw:t.slice(o),line:e,col:n,offset:o,endOffset:t.length})}return{tokens:r,comments:n.comments,error:a}}}exports.CdnSyntaxError=e.I,exports.adjustAppSeqIndicator=e.t,exports.adjustRawAppSeqSource=e.n,exports.canonicalEncodingWidth=e.r,exports.decideTaggedAppSeqRendering=e.o,exports.resolveEiSuffix=e.C,exports.tokenize=t,exports.tokenizeLenient=n;
 //# sourceMappingURL=index.cjs.map

package/dist/cdn/index.js

@@ -1,4 +1,4 @@
-import { A as e, C as t, I as n, n as r, o as i, r as a, t as o } from "../serialize-utils-BuIZPaUc.js";
+import { A as e, C as t, I as n, n as r, o as i, r as a, t as o } from "../serialize-utils-BQtutOo6.js";
 //#region src/cdn/index.ts
 function s(t) {
 	let n = new e(t), r = [];