@cbortech/cbor 0.26.5 → 0.26.6

package/dist/cddl/errors.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Structured errors thrown by the CDDL tokenizer, parser, and compiler.
+ *
+ * Both carry source positions so tooling (editors, linters, playgrounds) can
+ * point at the offending range without parsing the message.
+ */
+/** A semantic problem found while compiling a syntactically valid CDDL file. */
+export interface CddlWarning {
+    /** Stable machine-readable identifier, e.g. 'undefined-name'. */
+    code: 'no-rules' | 'duplicate-rule' | 'undefined-name' | 'generic-arity' | 'invalid-major' | 'invalid-root';
+    message: string;
+    /** Character offset of the start of the offending range in the source input. */
+    start?: number;
+    /** Character offset just past the end of the offending range. */
+    end?: number;
+}
+/**
+ * A single validation failure. When a data item does not match the schema,
+ * the reported error is the one recorded at the deepest point the matcher
+ * reached (failures discarded by backtracking are noise and are not kept).
+ */
+export interface CddlValidationError {
+    message: string;
+    /** Location inside the instance, e.g. '/claims/2/name' ('' = root). */
+    path: string;
+    /** Instance-side source offsets (byte offsets for CBOR input, character
+     *  offsets for CDN input), when the input carried them. */
+    start?: number;
+    end?: number;
+    /** The CDDL rule being matched when the failure was recorded. */
+    ruleName?: string;
+    /** Schema-side source offsets of the CDDL construct that failed to match. */
+    schemaStart?: number;
+    schemaEnd?: number;
+}
+/** A non-fatal observation made while validating (e.g. unsupported control
+ *  operators, whose targets are then matched without the constraint). */
+export interface CddlValidationWarning {
+    message: string;
+    schemaStart?: number;
+    schemaEnd?: number;
+}
+/** Result of {@link CddlSchema.validate}. */
+export interface ValidationResult {
+    valid: boolean;
+    /** Empty when valid; otherwise the deepest-reach failure(s). */
+    errors: CddlValidationError[];
+    /** Present when the validator had to approximate or skip constraints. */
+    warnings?: CddlValidationWarning[];
+}
+/** Syntax error thrown by the CDDL tokenizer and parser. */
+export declare class CddlSyntaxError extends SyntaxError {
+    /** Character offset of the start of the offending range in the source input. */
+    readonly offset?: number;
+    /** 1-based line number of the offending range. */
+    readonly line?: number;
+    /** 1-based column number of the offending range. */
+    readonly column?: number;
+    /** Character offset just past the end of the offending range. */
+    readonly endOffset?: number;
+    constructor(message: string, position?: {
+        offset?: number;
+        line?: number;
+        column?: number;
+        endOffset?: number;
+    });
+}
+/**
+ * Error thrown when a data item does not match a CDDL schema supplied via
+ * the `cddl` option of a throwing entry point (`CBOR.parse`, `CBOR.decode`,
+ * `CBOR.fromCDN`, `CBOR.encode`, …). Non-throwing checks (`CBOR.validate`,
+ * `CddlSchema.validate`) report the same failures in their result instead.
+ */
+export declare class CddlMismatchError extends Error {
+    /** The deepest-reach validation failure(s). */
+    readonly errors: CddlValidationError[];
+    /** Non-fatal validator observations (approximated/skipped constraints). */
+    readonly warnings: CddlValidationWarning[];
+    constructor(errors: CddlValidationError[], warnings?: CddlValidationWarning[]);
+}
+/**
+ * Semantic error thrown by `CDDL.compile` in strict mode (the default) when
+ * a syntactically valid file has semantic problems: undefined names,
+ * duplicate rule definitions, generic arity mismatches, and the like.
+ * With `strict: false` the same problems are collected into
+ * `CddlSchema.warnings` instead.
+ */
+export declare class CddlSemanticError extends Error {
+    readonly warnings: CddlWarning[];
+    constructor(warnings: CddlWarning[]);
+}

package/dist/cddl/index.cjs

@@ -0,0 +1,3 @@
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("../schema-BmGsaEaW.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;
+//# sourceMappingURL=index.cjs.map

package/dist/cddl/index.cjs.map

@@ -0,0 +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"}

package/dist/cddl/index.d.ts

@@ -0,0 +1,52 @@
+import { CddlComment, CddlToken } from './tokenizer';
+import { CddlSyntaxError } from './errors';
+import { CddlSchema, CompileOptions } from './schema';
+export type { CddlToken, CddlTokenType, CddlComment } from './tokenizer';
+export { CddlSyntaxError, CddlSemanticError, CddlMismatchError, } from './errors';
+export type { CddlWarning, CddlValidationError, CddlValidationWarning, ValidationResult, } from './errors';
+export type { ValidateOptions } from './validator';
+export { CddlSchema } from './schema';
+export type { CompileOptions } from './schema';
+export { parseCDDL } from './parser';
+export type { ParseCddlResult } from './parser';
+export { PRELUDE_CDDL, getPreludeRules } from './prelude';
+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';
+/** Main CDDL facade — mirrors the shape of the `CBOR` facade. */
+export declare class CDDL {
+    /**
+     * Parse and compile a CDDL data model.
+     *
+     * @example
+     * const schema = CDDL.compile(`person = { name: tstr, ? age: uint }`);
+     * schema.root.name;  // 'person'
+     */
+    static compile(text: string, options?: CompileOptions): CddlSchema;
+}
+export default CDDL;
+export interface TokenizeResult {
+    /** Scanned tokens in source order, excluding the final EOF token. */
+    tokens: CddlToken[];
+    /** Comments encountered while scanning, in source order. */
+    comments: CddlComment[];
+}
+export interface TokenizeLenientResult extends TokenizeResult {
+    /**
+     * The scan failure, if any. When set, `tokens` ends with a synthetic
+     * `ERROR` token covering the source from the last clean token to the end
+     * of the input.
+     */
+    error?: CddlSyntaxError;
+}
+/**
+ * Tokenize CDDL text. Throws {@link CddlSyntaxError} on invalid input.
+ */
+export declare function tokenize(text: string): TokenizeResult;
+/**
+ * Error-tolerant tokenization for editors and highlighters: never throws on
+ * invalid input. Tokens before the failure are returned as scanned; the
+ * remainder of the input is covered by a single synthetic `ERROR` token and
+ * the failure is reported in `error`.
+ */
+export declare function tokenizeLenient(text: string): TokenizeLenientResult;

package/dist/cddl/index.js

@@ -0,0 +1,67 @@
+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-BxkgvUY6.js";
+//#region src/cddl/position.ts
+function l(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
+	};
+}
+//#endregion
+//#region src/cddl/index.ts
+var u = class {
+	static compile(e, t) {
+		return i(e, t);
+	}
+};
+function d(e) {
+	let t = new a(e), n = [];
+	for (;;) {
+		let e = t.consume();
+		if (e.type === "EOF") break;
+		n.push(e);
+	}
+	return {
+		tokens: n,
+		comments: t.comments
+	};
+}
+function f(e) {
+	let t = new a(e), n = [];
+	try {
+		for (;;) {
+			let e = t.consume();
+			if (e.type === "EOF") break;
+			n.push(e);
+		}
+		return {
+			tokens: n,
+			comments: t.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({
+				type: "ERROR",
+				value: e.slice(o),
+				raw: e.slice(o),
+				line: t,
+				col: r,
+				offset: o,
+				endOffset: e.length
+			});
+		}
+		return {
+			tokens: n,
+			comments: t.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 };
+
+//# sourceMappingURL=index.js.map

package/dist/cddl/index.js.map

@@ -0,0 +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"}

package/dist/cddl/parser.d.ts

@@ -0,0 +1,13 @@
+import { CddlComment } from './tokenizer';
+import { CddlRule } from './ast';
+export interface ParseCddlResult {
+    /** Rules in source order (unmerged; `/=` and `//=` appear as-is). */
+    rules: CddlRule[];
+    /** `;` comments encountered while scanning, in source order. */
+    comments: CddlComment[];
+}
+/**
+ * Parse CDDL text into rule ASTs.
+ * Throws {@link CddlSyntaxError} on invalid input.
+ */
+export declare function parseCDDL(text: string): ParseCddlResult;

package/dist/cddl/position.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Convert a character offset (as carried by CDDL AST nodes, CddlWarning,
+ * and CddlValidationError.schemaStart/schemaEnd or start/end for CDN input)
+ * into a 1-based line/column position, for CLI-style `file:line:col`
+ * reporting.
+ *
+ * Offsets are JS string indices (UTF-16 code units), matching everything
+ * else in this library. Offsets past the end of the text clamp to its end.
+ */
+export declare function positionAt(text: string, offset: number): {
+    line: number;
+    column: number;
+};

package/dist/cddl/prelude.d.ts

@@ -0,0 +1,5 @@
+import { CddlRule } from './ast';
+/** Verbatim text of the RFC 8610 Appendix D standard prelude. */
+export declare const PRELUDE_CDDL = "any = #\n\nuint = #0\nnint = #1\nint = uint / nint\n\nbstr = #2\nbytes = bstr\ntstr = #3\ntext = tstr\n\ntdate = #6.0(tstr)\ntime = #6.1(number)\nnumber = int / float\nbiguint = #6.2(bstr)\nbignint = #6.3(bstr)\nbigint = biguint / bignint\ninteger = int / bigint\nunsigned = uint / biguint\ndecfrac = #6.4([e10: int, m: integer])\nbigfloat = #6.5([e2: int, m: integer])\neb64url = #6.21(any)\neb64legacy = #6.22(any)\neb16 = #6.23(any)\nencoded-cbor = #6.24(bstr)\nuri = #6.32(tstr)\nb64url = #6.33(tstr)\nb64legacy = #6.34(tstr)\nregexp = #6.35(tstr)\nmime-message = #6.36(tstr)\ncbor-any = #6.55799(any)\n\nfloat16 = #7.25\nfloat32 = #7.26\nfloat64 = #7.27\nfloat16-32 = float16 / float32\nfloat32-64 = float32 / float64\nfloat = float16-32 / float64\n\nfalse = #7.20\ntrue = #7.21\nbool = false / true\nnil = #7.22\nnull = nil\nundefined = #7.23\n";
+/** The parsed prelude rules by name, parsed once and cached. */
+export declare function getPreludeRules(): Map<string, CddlRule>;

package/dist/cddl/schema.d.ts

@@ -0,0 +1,90 @@
+import { CddlFormatOptions } from './writer';
+import { CddlComment } from './tokenizer';
+import { ValidateOptions } from './validator';
+import { CborItem } from '../ast/CborItem';
+import { CddlWarning, ValidationResult } from './errors';
+import { CddlRule } from './ast';
+export interface CompileOptions {
+    /**
+     * When true (the default), semantic problems (undefined names, duplicate
+     * rules, generic arity mismatches) throw a {@link CddlSemanticError}.
+     * When false, they are collected into {@link CddlSchema.warnings}.
+     */
+    strict?: boolean;
+}
+/**
+ * A compiled CDDL data model.
+ *
+ * `rules` maps each rule name to its definitions in source order: the base
+ * definition plus any `/=` / `//=` choice extensions. User rules shadow
+ * prelude names; the prelude itself is available via `getPreludeRules()`.
+ */
+export declare class CddlSchema {
+    /**
+     * The CDDL source text this schema was compiled from. AST node offsets
+     * (and validation errors' `schemaStart`/`schemaEnd`) index into it, so
+     * tooling can render positions without carrying the text separately.
+     */
+    readonly source: string;
+    /** `;` comments collected while parsing, in source order. */
+    readonly comments: readonly CddlComment[];
+    /** All rules in source order, as parsed (extensions unmerged). */
+    readonly ast: readonly CddlRule[];
+    /** Rule definitions by name (base definition first, then extensions). */
+    readonly rules: ReadonlyMap<string, readonly CddlRule[]>;
+    /**
+     * The root of the data model: the first rule in the source (RFC 8610 §3.1).
+     * Unset only for an empty model compiled with `strict: false`.
+     */
+    readonly root?: CddlRule;
+    /** Semantic problems collected with `strict: false`; unset when clean. */
+    readonly warnings?: CddlWarning[];
+    /** @internal — use `CDDL.compile()`. */
+    constructor(source: string, comments: readonly CddlComment[], ast: CddlRule[], rules: Map<string, CddlRule[]>, root: CddlRule | undefined, warnings: CddlWarning[]);
+    /**
+     * Serialize the data model back to CDDL text.
+     *
+     * Compact one-rule-per-line output by default; pass `indent` for a
+     * pretty layout (one group entry per line) and `preserveComments` to
+     * re-emit `;` comments.
+     *
+     * @example
+     * CDDL.compile(text).format({ indent: 2, preserveComments: true });
+     */
+    format(options?: CddlFormatOptions): string;
+    /**
+     * Validate a data item against this schema's root rule — the first rule
+     * in source order (RFC 8610 §3.1). Pass `{ rule: 'otherName' }` to
+     * validate against a different rule instead: any non-generic rule usable
+     * as a type, defined in the schema or its prelude (e.g. `'uint'`).
+     * Generic rules (`g<T> = ...`) and group-only rules are reported as
+     * validation failures, as is an unknown name (see
+     * {@link ValidateOptions.rule}).
+     *
+     * Accepts a CborItem, CBOR bytes (decoded with `decodeCBOR`), or CDN text
+     * (parsed with `parseCDN`). Validation failures are reported in the
+     * result, not thrown; decode/parse failures of the input throw as usual.
+     *
+     * @example
+     * const schema = CDDL.compile('person = { name: tstr, ? age: uint }');
+     * const result = schema.validate('{"name": "kudo", "age": 42}');
+     * result.valid; // true
+     *
+     * @example
+     * // Validate against a rule other than the root.
+     * const schema = CDDL.compile(`
+     *   p1 = { name: tstr, ? addr: tstr }
+     *   p2 = { name: tstr, ? age: uint }
+     * `);
+     * schema.validate('{"name": "kudo", "age": 42}', { rule: 'p2' }).valid; // true
+     */
+    validate(input: CborItem | Uint8Array | string, options?: ValidateOptions): ValidationResult;
+}
+/**
+ * Parse and compile CDDL text.
+ *
+ * Throws `CddlSyntaxError` on grammar errors. Semantic problems throw a
+ * {@link CddlSemanticError} by default; pass `strict: false` to collect them
+ * into `schema.warnings` instead.
+ */
+export declare function compile(text: string, options?: CompileOptions): CddlSchema;

package/dist/cddl/tokenizer.d.ts

@@ -0,0 +1,138 @@
+/**
+ * CDDL lexer (internal).
+ *
+ * Implements the token-level grammar of RFC 8610 as updated by RFC 9682
+ * (Appendix A collected ABNF). Used by parser.ts and exposed through the
+ * `tokenize()` / `tokenizeLenient()` helpers in index.ts so tooling such as
+ * syntax highlighters stays in exact agreement with parsing behavior.
+ */
+export type CddlTokenType = 'ID' | 'INT' | 'FLOAT' | 'TSTR' | 'BYTES' | 'HASH' | 'ASSIGN' | 'SLASH_EQ' | 'DSLASH_EQ' | 'SLASH' | 'DSLASH' | 'COMMA' | 'LPAREN' | 'RPAREN' | 'LBRACE' | 'RBRACE' | 'LBRACKET' | 'RBRACKET' | 'LT' | 'GT' | 'TILDE' | 'AMP' | 'RANGE_INCL' | 'RANGE_EXCL' | 'CTLOP' | 'STAR' | 'PLUS' | 'QUEST' | 'ARROW' | 'COLON' | 'CARET' | 'EOF'
+/** Synthetic token emitted by tokenizeLenient() for the unscannable tail. */
+ | 'ERROR';
+export interface CddlToken {
+    type: CddlTokenType;
+    /** Processed value: decoded string content, raw numeric text, id text, etc. */
+    value: string;
+    /** Original source text for this token. */
+    raw: string;
+    line: number;
+    col: number;
+    /** Character offset of the first character of this token in the source input. */
+    offset: number;
+    /** Character offset just past the last character of this token in the source input. */
+    endOffset: number;
+    /** Only set when type === 'BYTES': the qualifier ('' | 'h' | 'b64'). */
+    qualifier?: '' | 'h' | 'b64';
+    /** Only set when type === 'BYTES': the decoded byte content. */
+    bytes?: Uint8Array;
+    /** Only set when type === 'HASH': the major digit (0–9), absent for bare '#'. */
+    hashMajor?: number;
+    /** Only set when type === 'HASH': the literal head-number after the dot. */
+    hashAI?: bigint;
+    /**
+     * Only set when type === 'HASH': the head-number is a `<type>` expression
+     * (RFC 9682 §3.2); the tokens for `<` type `>` follow this token.
+     */
+    hashAIExpr?: boolean;
+}
+/** A `;` line comment collected while scanning. */
+export interface CddlComment {
+    /** Comment text after the ';' marker, without the trailing newline. */
+    text: string;
+    start: number;
+    end: number;
+    line: number;
+    col: number;
+}
+export declare class CddlTokenizer {
+    private readonly input;
+    private pos;
+    private line;
+    private col;
+    /** Comments encountered while scanning, in source order. */
+    readonly comments: CddlComment[];
+    /** Character offset just past the last successfully scanned token. */
+    lastEndOffset: number;
+    constructor(input: string);
+    private _eof;
+    private _ch;
+    private _advance;
+    private _fail;
+    /**
+     * Skip S = *(SP / NL) where NL = COMMENT / CRLF.
+     *
+     * Per the ABNF only SP (0x20), LF, and CRLF are whitespace; horizontal tab
+     * is not valid CDDL whitespace and is rejected with a targeted message.
+     * Deliberate leniency: a bare CR (not part of CRLF) is also accepted as
+     * whitespace, as source-level line-ending normalization.
+     */
+    private _skipWs;
+    /**
+     * COMMENT = ";" *PCHAR CRLF — collected into `this.comments`.
+     *
+     * Deliberate leniency: content characters are not PCHAR-validated, and a
+     * comment terminated by end-of-input (no trailing newline) is accepted.
+     */
+    private _scanComment;
+    private _make;
+    /** Scan and return the next token (skipping whitespace and comments). */
+    consume(): CddlToken;
+    /**
+     * id = EALPHA *(*("-" / ".") (EALPHA / DIGIT))
+     *
+     * Interior '-' and '.' runs are allowed when followed by an EALPHA/DIGIT,
+     * so `a.b`, `a-b`, and even `tstr.size` are single ids (the ABNF note
+     * "space may be needed before the operator if type2 ends in a name" exists
+     * for exactly this reason). This includes `..`: RFC 8610 §2.2.2.1 says
+     * `min..max` "is not a range expression but a single name" — a range with
+     * a name on the left-hand side must be written `min .. max`.
+     */
+    private _scanIdText;
+    /**
+     * number = hexfloat / (int ["." fraction] ["e" exponent])
+     * hexfloat = ["-"] "0x" 1*HEXDIG ["." 1*HEXDIG] "p" exponent
+     * uint = DIGIT1 *DIGIT / "0x" 1*HEXDIG / "0b" 1*BINDIG / "0"
+     *
+     * The token `value` is the raw numeric text; the parser converts it.
+     * A '.' followed by another '.' is never consumed (range operator).
+     */
+    private _scanNumber;
+    /** Scan a uint (decimal / 0x / 0b) for a '#' head-number; returns raw text. */
+    private _scanUintRaw;
+    /**
+     * "#" — any
+     * "#" DIGIT ["." head-number] — major type (and tag/simple shorthands)
+     * head-number = uint / "<" type ">"   (RFC 9682 §3.2)
+     *
+     * The '#', major digit, and a literal head-number are fused into a single
+     * HASH token (they must be adjacent in the source; `# 6` is a bare '#'
+     * followed by the value 6). For the `<type>` form, hashAIExpr is set and
+     * the `<` type `>` tokens follow.
+     */
+    private _scanHash;
+    /** text = %x22 *SCHAR %x22 — single-line, strict SCHAR/SESC per RFC 9682. */
+    private _scanText;
+    /**
+     * bytes = [bsqual] %x27 *BCHAR %x27
+     *
+     * Unqualified: content is UTF-8-encoded like a text string ('\'' must be
+     * escaped). Qualified h''/b64'': whitespace and ';' line comments inside
+     * the literal are ignored, then the rest is hex / base64 decoded
+     * (RFC 8610 §3.1).
+     */
+    private _scanBytes;
+    /**
+     * Read the body of a '"' text string or "'" byte string, decoding escapes.
+     *
+     * SCHAR = %x20-21 / %x23-5B / %x5D-7E / NONASCII / SESC
+     * BCHAR = %x20-26 / %x28-5B / %x5D-7E / NONASCII / SESC / "\'" / CRLF
+     * SESC  = "\" ( %x22 / "/" / "\" / b / f / n / r / t / (%x75 hexchar) )
+     */
+    private _readStringBody;
+    /**
+     * hexchar (RFC 9682): after `\u`, either `{...}` with a scalar value
+     * (leading zeros allowed, surrogates rejected) or 4 hex digits, where a
+     * high surrogate must be immediately followed by `\uXXXX` low surrogate.
+     */
+    private _readUnicodeEscape;
+}

package/dist/cddl/validator.d.ts

@@ -0,0 +1,30 @@
+import { CddlSchema } from './schema';
+import { CborItem } from '../ast/CborItem';
+import { ValidationResult } from './errors';
+import { CddlValue } from './ast';
+export interface ValidateOptions {
+    /** Recursion guard for rule references and nested groups (default 256). */
+    maxDepth?: number;
+    /** Total backtracking step budget (default 1e6). */
+    maxSteps?: number;
+    /** Feature names accepted by the `.feature` control operator. */
+    features?: string[];
+    /**
+     * Name of the rule to validate against, in place of the schema's root
+     * (the first rule in source order — RFC 8610 §3.1 defines only one root
+     * per model). Any non-generic rule usable as a type can be selected,
+     * defined in the schema or its prelude — e.g. a variant used only as a
+     * component elsewhere.
+     *
+     * An unknown name fails validation (`errors[0].message` is `'<name>' is
+     * not defined`) rather than throwing, matching how an unresolved `$ref`
+     * inside the schema is reported. A generic rule (`g<T> = ...`) also fails
+     * validation rather than throwing: there is no `genericArgs` site to bind
+     * its parameters from here, so it cannot be selected directly. Likewise a
+     * group-only rule fails with `group rule '<name>' cannot be used as a
+     * type`, exactly as when such a rule is referenced in type position.
+     */
+    rule?: string;
+}
+export declare function validateItem(schema: CddlSchema, item: CborItem, options?: ValidateOptions): ValidationResult;
+export declare function matchesLiteral(item: CborItem, v: CddlValue): boolean;

package/dist/cddl/writer.d.ts

@@ -0,0 +1,23 @@
+import { CddlComment } from './tokenizer';
+import { CddlRule } from './ast';
+export interface CddlFormatOptions {
+    /**
+     * Pretty-print groups with one entry per line, indented by this many
+     * spaces (or by the given string). Omit for compact single-line rules.
+     */
+    indent?: number | string;
+    /**
+     * Re-emit `;` comments. Rule-level comments are kept in both layouts;
+     * comments attached to group entries require `indent` (the pretty
+     * layout). Only effective when the formatter has the comment stream and
+     * source text — i.e. when called through `CddlSchema.format()`.
+     */
+    preserveComments?: boolean;
+}
+/** @internal Extras supplied by CddlSchema.format(). */
+export interface CddlFormatContext {
+    source?: string;
+    comments?: readonly CddlComment[];
+}
+/** Format rules (in the given order) as CDDL text with a trailing newline. */
+export declare function formatCddl(rules: readonly CddlRule[], options?: CddlFormatOptions & CddlFormatContext): string;