@cbortech/cbor 0.26.5 → 0.26.7

package/dist/schema-Bofmsptw.js

@@ -0,0 +1,1977 @@
+import { a as e } from "./tokenizer-CeuixxXi.js";
+import { A as t, D as n, E as r, F as i, I as a, L as o, M as s, N as c, O as l, P as u, T as d, _ as f, b as p, g as m, h, j as g, k as ee, u as te, v as ne, w as re, x as ie, y as _ } from "./mapEntries-DxrDre2P.js";
+//#region src/cddl/errors.ts
+var v = class extends SyntaxError {
+	offset;
+	line;
+	column;
+	endOffset;
+	constructor(e, t) {
+		let n = t?.line === void 0 ? "" : ` at line ${t.line}, column ${t.column}`;
+		super(`CDDL parse error${n}: ${e}`), this.name = "CddlSyntaxError", this.offset = t?.offset, this.line = t?.line, this.column = t?.column, this.endOffset = t?.endOffset;
+	}
+}, ae = class extends Error {
+	errors;
+	warnings;
+	constructor(e, t = []) {
+		let n = e[0], r = n?.path ? ` at ${n.path}` : "", i = e.length > 1 ? ` (and ${e.length - 1} more)` : "";
+		super(`CDDL validation failed${r}: ${n?.message ?? "unknown"}${i}`), this.name = "CddlMismatchError", this.errors = e, this.warnings = t;
+	}
+}, oe = class extends Error {
+	warnings;
+	constructor(e) {
+		let t = e[0], n = e.length > 1 ? ` (and ${e.length - 1} more)` : "";
+		super(`CDDL semantic error: ${t?.message ?? "unknown"}${n}`), this.name = "CddlSemanticError", this.warnings = e;
+	}
+}, se = new TextEncoder(), y = (e) => e >= "0" && e <= "9", b = (e) => y(e) || e >= "a" && e <= "f" || e >= "A" && e <= "F", x = (e) => e >= "a" && e <= "z" || e >= "A" && e <= "Z" || e === "@" || e === "_" || e === "$", ce = (e) => e >= 160 && e <= 55295 || e >= 57344 && e <= 1114109, le = class {
+	input;
+	pos = 0;
+	line = 1;
+	col = 1;
+	comments = [];
+	lastEndOffset = 0;
+	constructor(e) {
+		this.input = e;
+	}
+	_eof() {
+		return this.pos >= this.input.length;
+	}
+	_ch() {
+		return this.input[this.pos] ?? "";
+	}
+	_advance() {
+		let e = this.input[this.pos] ?? "";
+		return this.pos++, e === "\n" ? (this.line++, this.col = 1) : this.col++, e;
+	}
+	_fail(e, t, n) {
+		throw new v(e, {
+			offset: this.pos,
+			line: t ?? this.line,
+			column: n ?? this.col
+		});
+	}
+	_skipWs() {
+		for (;;) {
+			let e = this._ch();
+			if (e === " " || e === "\n" || e === "\r") {
+				this._advance();
+				continue;
+			}
+			if (e === "	" && this._fail("horizontal tab is not valid whitespace in CDDL (RFC 8610 ABNF allows only space and newline)"), e === ";") {
+				this._scanComment();
+				continue;
+			}
+			return;
+		}
+	}
+	_scanComment() {
+		let e = this.pos, t = this.line, n = this.col;
+		this._advance();
+		let r = this.pos;
+		for (; r < this.input.length;) {
+			let e = this.input[r];
+			if (e === "\n" || e === "\r") break;
+			r++;
+		}
+		let i = this.input.slice(this.pos, r);
+		this.col += r - this.pos, this.pos = r, this.comments.push({
+			text: i,
+			start: e,
+			end: r,
+			line: t,
+			col: n
+		});
+	}
+	_make(e, t, n, r, i, a) {
+		let o = {
+			type: e,
+			value: t,
+			raw: this.input.slice(n, this.pos),
+			line: r,
+			col: i,
+			offset: n,
+			endOffset: this.pos,
+			...a
+		};
+		return this.lastEndOffset = this.pos, o;
+	}
+	consume() {
+		this._skipWs();
+		let e = this.pos, t = this.line, n = this.col;
+		if (this._eof()) return this._make("EOF", "", e, t, n);
+		let r = this._ch();
+		if (x(r)) {
+			let r = this._scanIdText();
+			return (r === "h" || r === "b64") && this._ch() === "'" ? this._scanBytes(r, e, t, n) : this._make("ID", r, e, t, n);
+		}
+		if (y(r) || r === "-") return this._scanNumber(e, t, n);
+		if (r === "\"") return this._scanText(e, t, n);
+		if (r === "'") return this._scanBytes("", e, t, n);
+		if (r === "#") return this._scanHash(e, t, n);
+		switch (r) {
+			case "=": return this._advance(), this._ch() === ">" ? (this._advance(), this._make("ARROW", "=>", e, t, n)) : this._make("ASSIGN", "=", e, t, n);
+			case "/": return this._advance(), this._ch() === "/" ? (this._advance(), this._ch() === "=" ? (this._advance(), this._make("DSLASH_EQ", "//=", e, t, n)) : this._make("DSLASH", "//", e, t, n)) : this._ch() === "=" ? (this._advance(), this._make("SLASH_EQ", "/=", e, t, n)) : this._make("SLASH", "/", e, t, n);
+			case ".": {
+				if (this._advance(), this._ch() === ".") return this._advance(), this._ch() === "." ? (this._advance(), this._make("RANGE_EXCL", "...", e, t, n)) : this._make("RANGE_INCL", "..", e, t, n);
+				x(this._ch()) || this._fail(`expected a control operator name after '.' (e.g. .size), got ${this._eof() ? "end of input" : JSON.stringify(this._ch())}`, t, n);
+				let r = this._scanIdText();
+				return this._make("CTLOP", r, e, t, n);
+			}
+			case ",": return this._advance(), this._make("COMMA", ",", e, t, n);
+			case "(": return this._advance(), this._make("LPAREN", "(", e, t, n);
+			case ")": return this._advance(), this._make("RPAREN", ")", e, t, n);
+			case "{": return this._advance(), this._make("LBRACE", "{", e, t, n);
+			case "}": return this._advance(), this._make("RBRACE", "}", e, t, n);
+			case "[": return this._advance(), this._make("LBRACKET", "[", e, t, n);
+			case "]": return this._advance(), this._make("RBRACKET", "]", e, t, n);
+			case "<": return this._advance(), this._make("LT", "<", e, t, n);
+			case ">": return this._advance(), this._make("GT", ">", e, t, n);
+			case "~": return this._advance(), this._make("TILDE", "~", e, t, n);
+			case "&": return this._advance(), this._make("AMP", "&", e, t, n);
+			case "*": return this._advance(), this._make("STAR", "*", e, t, n);
+			case "+": return this._advance(), this._make("PLUS", "+", e, t, n);
+			case "?": return this._advance(), this._make("QUEST", "?", e, t, n);
+			case ":": return this._advance(), this._make("COLON", ":", e, t, n);
+			case "^": return this._advance(), this._make("CARET", "^", e, t, n);
+			default: this._fail(`unexpected character ${JSON.stringify(r)}`);
+		}
+	}
+	_scanIdText() {
+		let e = this.pos;
+		for (this._advance();;) {
+			let e = this._ch();
+			if (x(e) || y(e)) {
+				this._advance();
+				continue;
+			}
+			if (e === "-" || e === ".") {
+				let e = this.pos;
+				for (; this.input[e] === "-" || this.input[e] === ".";) e++;
+				let t = this.input[e] ?? "";
+				if (!(x(t) || y(t))) break;
+				for (; this.pos <= e;) this._advance();
+				continue;
+			}
+			break;
+		}
+		return this.input.slice(e, this.pos);
+	}
+	_scanNumber(e, t, n) {
+		this._ch() === "-" && this._advance(), y(this._ch()) || this._fail("expected a digit after '-'", t, n);
+		let r = !1;
+		if (this._ch() === "0" && /[xX]/.test(this.input[this.pos + 1] ?? "")) {
+			for (this._advance(), this._advance(), b(this._ch()) || this._fail("expected hex digits after 0x", t, n); b(this._ch());) this._advance();
+			if (this._ch() === "." && b(this.input[this.pos + 1] ?? "") && this.input[this.pos + 1] !== void 0) {
+				for (this._advance(); b(this._ch());) this._advance();
+				/[pP]/.test(this._ch()) || this._fail("hexadecimal fraction requires a 'p' exponent (hexfloat)", t, n);
+			}
+			if (/[pP]/.test(this._ch())) {
+				for (this._advance(), (this._ch() === "+" || this._ch() === "-") && this._advance(), y(this._ch()) || this._fail("expected exponent digits after 'p'", t, n); y(this._ch());) this._advance();
+				r = !0;
+			}
+		} else if (this._ch() === "0" && /[bB]/.test(this.input[this.pos + 1] ?? "")) for (this._advance(), this._advance(), /[01]/.test(this._ch()) || this._fail("expected binary digits after 0b", t, n); /[01]/.test(this._ch());) this._advance();
+		else {
+			for (this._ch() === "0" && y(this.input[this.pos + 1] ?? "") && this._fail("leading zeros are not allowed in CDDL numbers", t, n); y(this._ch());) this._advance();
+			if (this._ch() === "." && y(this.input[this.pos + 1] ?? "")) {
+				for (this._advance(); y(this._ch());) this._advance();
+				r = !0;
+			}
+			if (/[eE]/.test(this._ch())) {
+				for (this._advance(), (this._ch() === "+" || this._ch() === "-") && this._advance(), y(this._ch()) || this._fail("expected exponent digits after 'e'", t, n); y(this._ch());) this._advance();
+				r = !0;
+			}
+		}
+		let i = this.input.slice(e, this.pos);
+		return this._make(r ? "FLOAT" : "INT", i, e, t, n);
+	}
+	_scanUintRaw() {
+		let e = this.pos;
+		if (y(this._ch()) || this._fail("expected an unsigned integer head-number"), this._ch() === "0" && /[xX]/.test(this.input[this.pos + 1] ?? "")) for (this._advance(), this._advance(), b(this._ch()) || this._fail("expected hex digits after 0x"); b(this._ch());) this._advance();
+		else if (this._ch() === "0" && /[bB]/.test(this.input[this.pos + 1] ?? "")) for (this._advance(), this._advance(), /[01]/.test(this._ch()) || this._fail("expected binary digits after 0b"); /[01]/.test(this._ch());) this._advance();
+		else for (this._ch() === "0" && y(this.input[this.pos + 1] ?? "") && this._fail("leading zeros are not allowed in CDDL numbers"); y(this._ch());) this._advance();
+		return this.input.slice(e, this.pos);
+	}
+	_scanHash(e, t, n) {
+		this._advance();
+		let r = {};
+		return y(this._ch()) && (r.hashMajor = this._advance().charCodeAt(0) - 48, this._ch() === "." && (this.input[this.pos + 1] === "<" ? (this._advance(), r.hashAIExpr = !0) : (this._advance(), r.hashAI = BigInt(this._scanUintRaw())))), this._make("HASH", this.input.slice(e, this.pos), e, t, n, r);
+	}
+	_scanText(e, t, n) {
+		let r = this._readStringBody("\"");
+		return this._make("TSTR", r, e, t, n);
+	}
+	_scanBytes(t, n, r, i) {
+		let a = this._readStringBody("'"), o;
+		if (t === "") o = se.encode(a);
+		else {
+			let s = ue(a);
+			try {
+				o = t === "h" ? e(s) : ie(s);
+			} catch (e) {
+				throw !(e instanceof SyntaxError) || e instanceof v ? e : new v(e.message, {
+					offset: n,
+					line: r,
+					column: i,
+					endOffset: this.pos
+				});
+			}
+		}
+		return this._make("BYTES", a, n, r, i, {
+			qualifier: t,
+			bytes: o
+		});
+	}
+	_readStringBody(e) {
+		let t = e === "'";
+		this._advance();
+		let n = "";
+		for (;;) {
+			this._eof() && this._fail(`unterminated ${t ? "byte" : "text"} string literal`);
+			let r = this._ch();
+			if (r === e) return this._advance(), n;
+			if (r === "\\") {
+				let e = this.line, r = this.col;
+				this._advance();
+				let i = this._advance();
+				switch (i) {
+					case "\"":
+						n += "\"";
+						break;
+					case "/":
+						n += "/";
+						break;
+					case "\\":
+						n += "\\";
+						break;
+					case "b":
+						n += "\b";
+						break;
+					case "f":
+						n += "\f";
+						break;
+					case "n":
+						n += "\n";
+						break;
+					case "r":
+						n += "\r";
+						break;
+					case "t":
+						n += "	";
+						break;
+					case "u":
+						n += this._readUnicodeEscape(e, r);
+						break;
+					case "'":
+						t || this._fail("\\' is only valid in byte string literals; text strings do not need it", e, r), n += "'";
+						break;
+					default: this._fail(`invalid escape sequence \\${i}`, e, r);
+				}
+				continue;
+			}
+			if (r === "\n" || r === "\r") {
+				t || this._fail("text string literals cannot span lines (escape the newline as \\n)"), r === "\r" ? (this._advance(), this._ch() !== "\n" && this._fail("bare CR is not allowed in byte string literals"), this._advance(), n += "\r\n") : (this._advance(), n += "\n");
+				continue;
+			}
+			let i = this.input.codePointAt(this.pos);
+			(i < 32 || i >= 127 && i <= 159) && this._fail(`unescaped control character U+${i.toString(16).padStart(4, "0").toUpperCase()} is not allowed in string literals`), i > 126 && !ce(i) && this._fail(`code point U+${i.toString(16).toUpperCase()} is not allowed in CDDL source`), this._advance(), i > 65535 && this._advance(), n += String.fromCodePoint(i);
+		}
+	}
+	_readUnicodeEscape(e, t) {
+		if (this._ch() === "{") {
+			this._advance();
+			let n = "";
+			for (; b(this._ch());) n += this._advance();
+			n.length === 0 && this._fail("\\u{} escape requires at least one hex digit", e, t), this._ch() !== "}" && this._fail("expected '}' to close \\u{...} escape", e, t), this._advance();
+			let r = parseInt(n, 16);
+			return r > 1114111 && this._fail(`\\u{${n}} is above the Unicode code point maximum U+10FFFF`, e, t), r >= 55296 && r <= 57343 && this._fail(`\\u{${n}} is a surrogate code point, not a Unicode scalar value`, e, t), String.fromCodePoint(r);
+		}
+		let n = () => {
+			let n = "";
+			for (let r = 0; r < 4; r++) b(this._ch()) || this._fail("\\u escape requires four hex digits", e, t), n += this._advance();
+			return parseInt(n, 16);
+		}, r = n();
+		if (r >= 55296 && r <= 56319) {
+			(this._ch() !== "\\" || this.input[this.pos + 1] !== "u") && this._fail("high surrogate \\u escape must be followed by a low surrogate \\u escape", e, t), this._advance(), this._advance();
+			let i = n();
+			return (i < 56320 || i > 57343) && this._fail("high surrogate \\u escape must be followed by a low surrogate \\u escape", e, t), String.fromCodePoint(65536 + (r - 55296 << 10) + (i - 56320));
+		}
+		return r >= 56320 && r <= 57343 && this._fail("lone low surrogate \\u escape", e, t), String.fromCodePoint(r);
+	}
+};
+function ue(e) {
+	let t = "", n = 0;
+	for (; n < e.length;) {
+		let r = e[n];
+		if (r === " " || r === "\n" || r === "\r") {
+			n++;
+			continue;
+		}
+		if (r === ";") {
+			for (; n < e.length && e[n] !== "\n";) n++;
+			continue;
+		}
+		t += r, n++;
+	}
+	return t;
+}
+//#endregion
+//#region src/cddl/parser.ts
+function S(e) {
+	let t = new le(e);
+	return {
+		rules: new fe(t).parse(),
+		comments: t.comments
+	};
+}
+var de = /* @__PURE__ */ new Set([
+	"SLASH",
+	"RANGE_INCL",
+	"RANGE_EXCL",
+	"CTLOP",
+	"ARROW",
+	"CARET"
+]), fe = class {
+	t;
+	buf = [];
+	constructor(e) {
+		this.t = e;
+	}
+	peek(e = 0) {
+		for (; this.buf.length <= e;) this.buf.push(this.t.consume());
+		return this.buf[e];
+	}
+	consume() {
+		return this.buf.shift() ?? this.t.consume();
+	}
+	expect(e, t) {
+		let n = this.peek();
+		return n.type !== e && this._fail(`expected ${t}`, n), this.consume();
+	}
+	_fail(e, t) {
+		throw new v(`${e}, got ${t.type === "EOF" ? "end of input" : `${JSON.stringify(t.raw)}`}`, {
+			offset: t.offset,
+			endOffset: t.endOffset,
+			line: t.line,
+			column: t.col
+		});
+	}
+	parse() {
+		let e = [];
+		for (; this.peek().type !== "EOF";) e.push(this.parseRule());
+		return e;
+	}
+	parseRule() {
+		let e = this.expect("ID", "a rule name"), t;
+		if (this.peek().type === "LT") {
+			for (this.consume(), t = [this.expect("ID", "a generic parameter name").value]; this.peek().type === "COMMA";) this.consume(), t.push(this.expect("ID", "a generic parameter name").value);
+			this.expect("GT", "'>' after generic parameters");
+		}
+		let n = this.peek(), r;
+		n.type === "ASSIGN" ? r = "=" : n.type === "SLASH_EQ" ? r = "/=" : n.type === "DSLASH_EQ" ? r = "//=" : this._fail("expected '=', '/=' or '//=' after rule name", n), this.consume();
+		let i = r === "/=" ? this.parseTypeAsEntry() : this.parseGroupEntry();
+		return {
+			kind: "rule",
+			name: e.value,
+			...t ? { generics: t } : {},
+			assign: r,
+			body: i,
+			start: e.offset,
+			end: i.end
+		};
+	}
+	parseTypeAsEntry() {
+		let e = this.parseType();
+		return {
+			kind: "entry",
+			value: e,
+			start: e.start,
+			end: e.end
+		};
+	}
+	parseGroup(e) {
+		let t = this.peek().offset, n = [[]], r = !1;
+		for (;;) {
+			let t = this.peek();
+			if (t.type === e) break;
+			if (t.type === "EOF" && this._fail(`unterminated group; expected ${JSON.stringify(e)}`, t), t.type === "DSLASH") {
+				this.consume(), n.push([]), r = !1;
+				continue;
+			}
+			n[n.length - 1].push(this.parseGroupEntry()), r = this.peek().type === "COMMA", r && this.consume();
+		}
+		let i = this.peek();
+		return {
+			kind: "group",
+			choices: n,
+			...r ? { trailingComma: !0 } : {},
+			start: t,
+			end: i.offset
+		};
+	}
+	parseGroupEntry() {
+		let e = this.peek().offset, t = this.tryParseOccur();
+		if (this.peek().type === "LPAREN") {
+			let n = this.consume(), r = this.parseGroup("RPAREN"), i = this.consume();
+			if (de.has(this.peek().type)) {
+				let a = this.groupAsParenType(r, n, i), o = this.continueType1(a);
+				return this.finishEntryFromType1(e, t, o);
+			}
+			return {
+				kind: "entry-group",
+				...t ? { occur: t } : {},
+				group: r,
+				start: e,
+				end: i.endOffset
+			};
+		}
+		let n = this.peek(0);
+		if (this.peek(1).type === "COLON" && (n.type === "ID" || this.isValueToken(n))) {
+			let r;
+			if (n.type === "ID") {
+				this.consume();
+				let e = this.consume();
+				r = {
+					kind: "bareword",
+					key: n.value,
+					cut: !0,
+					start: n.offset,
+					end: e.endOffset
+				};
+			} else {
+				let e = this.parseValue(), t = this.consume();
+				r = {
+					kind: "value",
+					key: e,
+					cut: !0,
+					start: e.start,
+					end: t.endOffset
+				};
+			}
+			let i = this.parseType();
+			return {
+				kind: "entry",
+				...t ? { occur: t } : {},
+				memberKey: r,
+				value: i,
+				start: e,
+				end: i.end
+			};
+		}
+		let r = this.parseType1();
+		return this.finishEntryFromType1(e, t, r);
+	}
+	finishEntryFromType1(e, t, n) {
+		let r;
+		if (this.peek().type === "CARET" || this.peek().type === "ARROW") {
+			let e = !1;
+			this.peek().type === "CARET" && (this.consume(), e = !0);
+			let t = this.expect("ARROW", "'=>' after member key");
+			r = {
+				kind: "type1",
+				key: n,
+				cut: e,
+				start: n.start,
+				end: t.endOffset
+			};
+		}
+		let i = r ? this.parseType() : this.continueTypeAlternatives(n);
+		return {
+			kind: "entry",
+			...t ? { occur: t } : {},
+			...r ? { memberKey: r } : {},
+			value: i,
+			start: e,
+			end: i.end
+		};
+	}
+	tryParseOccur() {
+		let e = this.peek(0);
+		if (e.type === "QUEST") return this.consume(), {
+			kind: "occur",
+			marker: "?",
+			start: e.offset,
+			end: e.endOffset
+		};
+		if (e.type === "PLUS") return this.consume(), {
+			kind: "occur",
+			marker: "+",
+			start: e.offset,
+			end: e.endOffset
+		};
+		if (e.type === "STAR") {
+			this.consume();
+			let t, n = e.endOffset, r = this.peek();
+			return r.type === "INT" && r.offset === e.endOffset && (t = this.occurBound(this.consume()), n = r.endOffset), {
+				kind: "occur",
+				marker: "*",
+				...t === void 0 ? {} : { max: t },
+				start: e.offset,
+				end: n
+			};
+		}
+		if (e.type === "INT" && !e.value.startsWith("-") && this.peek(1).type === "STAR" && this.peek(1).offset === e.endOffset) {
+			let t = this.occurBound(this.consume()), n = this.consume(), r, i = n.endOffset, a = this.peek();
+			return a.type === "INT" && a.offset === n.endOffset && (r = this.occurBound(this.consume()), i = a.endOffset), {
+				kind: "occur",
+				marker: "*",
+				min: t,
+				max: r,
+				start: e.offset,
+				end: i
+			};
+		}
+	}
+	occurBound(e) {
+		e.value.startsWith("-") && this._fail("occurrence bounds must be unsigned integers", e);
+		let t = Number(e.value);
+		return Number.isSafeInteger(t) || this._fail("occurrence bound is too large", e), t;
+	}
+	parseType() {
+		return this.continueTypeAlternatives(this.parseType1());
+	}
+	continueTypeAlternatives(e) {
+		let t = [e];
+		for (; this.peek().type === "SLASH";) this.consume(), t.push(this.parseType1());
+		return {
+			kind: "type",
+			alternatives: t,
+			start: e.start,
+			end: t[t.length - 1].end
+		};
+	}
+	parseType1() {
+		return this.continueType1(this.parseType2());
+	}
+	continueType1(e) {
+		let t = this.peek(), n;
+		if (t.type === "RANGE_INCL" || t.type === "RANGE_EXCL" ? n = {
+			kind: "range",
+			inclusive: t.type === "RANGE_INCL"
+		} : t.type === "CTLOP" && (n = {
+			kind: "ctl",
+			name: t.value
+		}), !n) return {
+			kind: "type1",
+			target: e,
+			start: e.start,
+			end: e.end
+		};
+		this.consume();
+		let r = this.parseType2();
+		return {
+			kind: "type1",
+			target: e,
+			op: n,
+			controller: r,
+			start: e.start,
+			end: r.end
+		};
+	}
+	parseType2() {
+		let e = this.peek();
+		switch (e.type) {
+			case "INT":
+			case "FLOAT":
+			case "TSTR":
+			case "BYTES": return this.parseValue();
+			case "ID": return this.consume(), this.parseRefTail(e);
+			case "LPAREN": {
+				let e = this.consume(), t = this.parseType(), n = this.expect("RPAREN", "')' to close the parenthesized type");
+				return {
+					kind: "paren",
+					type: t,
+					start: e.offset,
+					end: n.endOffset
+				};
+			}
+			case "LBRACE": {
+				let e = this.consume(), t = this.parseGroup("RBRACE"), n = this.consume();
+				return {
+					kind: "map",
+					group: t,
+					start: e.offset,
+					end: n.endOffset
+				};
+			}
+			case "LBRACKET": {
+				let e = this.consume(), t = this.parseGroup("RBRACKET"), n = this.consume();
+				return {
+					kind: "array",
+					group: t,
+					start: e.offset,
+					end: n.endOffset
+				};
+			}
+			case "TILDE": {
+				let e = this.consume(), t = this.expect("ID", "a type name after '~'"), n = this.parseRefTail(t);
+				return {
+					kind: "unwrap",
+					ref: n,
+					start: e.offset,
+					end: n.end
+				};
+			}
+			case "AMP": {
+				let e = this.consume();
+				if (this.peek().type === "LPAREN") {
+					this.consume();
+					let t = this.parseGroup("RPAREN"), n = this.consume();
+					return {
+						kind: "enum",
+						group: t,
+						start: e.offset,
+						end: n.endOffset
+					};
+				}
+				let t = this.expect("ID", "a group name or '(' after '&'"), n = this.parseRefTail(t);
+				return {
+					kind: "enum",
+					group: n,
+					start: e.offset,
+					end: n.end
+				};
+			}
+			case "HASH": return this.parseHashType(this.consume());
+			default: this._fail("expected a type", e);
+		}
+	}
+	parseRefTail(e) {
+		if (this.peek().type !== "LT") return {
+			kind: "ref",
+			name: e.value,
+			start: e.offset,
+			end: e.endOffset
+		};
+		this.consume();
+		let t = [this.parseType1()];
+		for (; this.peek().type === "COMMA";) this.consume(), t.push(this.parseType1());
+		let n = this.expect("GT", "'>' after generic arguments");
+		return {
+			kind: "ref",
+			name: e.value,
+			genericArgs: t,
+			start: e.offset,
+			end: n.endOffset
+		};
+	}
+	parseHashType(e) {
+		if (e.hashMajor === void 0) return (e.hashAIExpr || e.hashAI !== void 0) && this._fail("'#' without a major type cannot take a head-number", e), {
+			kind: "any",
+			start: e.offset,
+			end: e.endOffset
+		};
+		let t = e.hashMajor, n = e.hashAI, r = e.endOffset;
+		e.hashAIExpr && (t !== 6 && t !== 7 && this._fail("a <type> head-number is only allowed for #6 and #7 (RFC 9682 §3.2)", e), this.expect("LT", "'<' for the head-number expression"), n = this.parseType(), r = this.expect("GT", "'>' after the head-number expression").endOffset);
+		let i = e.hashAIExpr ? void 0 : e.raw;
+		if (t === 6 && this.peek().type === "LPAREN") {
+			this.consume();
+			let t = this.parseType(), r = this.expect("RPAREN", "')' to close the tagged type");
+			return {
+				kind: "tagged",
+				...n === void 0 ? {} : { tag: n },
+				item: t,
+				...i === void 0 ? {} : { raw: i },
+				start: e.offset,
+				end: r.endOffset
+			};
+		}
+		return e.hashAIExpr && t === 6 && this._fail("#6.<…> must be followed by '(' type ')'", this.peek()), {
+			kind: "major",
+			major: t,
+			...n === void 0 ? {} : { ai: n },
+			...i === void 0 ? {} : { raw: i },
+			start: e.offset,
+			end: r
+		};
+	}
+	isValueToken(e) {
+		return e.type === "INT" || e.type === "FLOAT" || e.type === "TSTR" || e.type === "BYTES";
+	}
+	parseValue() {
+		let e = this.consume(), t = {
+			start: e.offset,
+			end: e.endOffset,
+			raw: e.raw
+		};
+		switch (e.type) {
+			case "INT": {
+				let n = e.value.startsWith("-") ? -BigInt(e.value.slice(1)) : BigInt(e.value);
+				return {
+					kind: "value",
+					type: "int",
+					value: n >= BigInt(-(2 ** 53 - 1)) && n <= BigInt(2 ** 53 - 1) ? Number(n) : n,
+					...t
+				};
+			}
+			case "FLOAT": return {
+				kind: "value",
+				type: "float",
+				value: /^-?0[xX]/.test(e.value) ? c(e.value) : parseFloat(e.value),
+				...t
+			};
+			case "TSTR": return {
+				kind: "value",
+				type: "text",
+				value: e.value,
+				...t
+			};
+			case "BYTES": return {
+				kind: "value",
+				type: "bytes",
+				value: e.bytes,
+				qualifier: e.qualifier,
+				...t
+			};
+			default: this._fail("expected a literal value", e);
+		}
+	}
+	groupAsParenType(e, t, n) {
+		let r = e.choices.length === 1 && e.choices[0].length === 1 ? e.choices[0][0] : void 0;
+		return (!r || r.kind !== "entry" || r.occur || r.memberKey || e.trailingComma) && this._fail("this parenthesized group is used as a type (an operator follows), but it contains group syntax", this.peek()), {
+			kind: "paren",
+			type: r.value,
+			start: t.offset,
+			end: n.endOffset
+		};
+	}
+}, pe = "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", C;
+function w() {
+	if (!C) {
+		C = /* @__PURE__ */ new Map();
+		for (let e of S(pe).rules) C.set(e.name, e);
+	}
+	return C;
+}
+//#endregion
+//#region src/cddl/writer.ts
+var me = {
+	leading: [],
+	trailing: []
+};
+function he(e, t) {
+	let n = {
+		unit: t?.indent === void 0 ? null : typeof t.indent == "string" ? t.indent : " ".repeat(t.indent),
+		notes: null,
+		endNotes: null,
+		tail: []
+	};
+	if (t?.preserveComments && t.comments !== void 0 && t.comments.length > 0 && t.source !== void 0) {
+		let r = ge(e, t.comments, t.source);
+		n.notes = r.notes, n.endNotes = r.endNotes, n.tail = r.tail;
+	}
+	let r = [], i = !1;
+	e.forEach((e, t) => {
+		let { text: a, multiline: o } = ve(e, n);
+		t > 0 && n.unit !== null && (o || i) && r.push(""), r.push(a), i = o;
+	});
+	for (let e of n.tail) r.push(`;${e}`);
+	return r.length === 0 ? "" : r.join("\n") + "\n";
+}
+function ge(e, t, n) {
+	let r = [0];
+	for (let e = 0; e < n.length; e++) n.charCodeAt(e) === 10 && r.push(e + 1);
+	let i = (e) => {
+		let t = 0, n = r.length - 1;
+		for (; t < n;) {
+			let i = t + n + 1 >> 1;
+			r[i] <= e ? t = i : n = i - 1;
+		}
+		return t + 1;
+	}, a = [], o = [], s = (e, t, n) => {
+		o.push({
+			group: e,
+			start: t,
+			end: n
+		});
+		for (let t of e.choices) t.forEach(c);
+	}, c = (e) => {
+		if (a.push({
+			node: e,
+			start: e.start,
+			end: e.end,
+			isRule: !1
+		}), e.kind === "entry-group") {
+			s(e.group, e.start, e.end);
+			return;
+		}
+		for (let t of e.value.alternatives) l(t);
+	}, l = (e) => {
+		u(e.target), e.controller && u(e.controller);
+	}, u = (e) => {
+		switch (e.kind) {
+			case "map":
+			case "array":
+				s(e.group, e.start, e.end);
+				return;
+			case "paren":
+				for (let t of e.type.alternatives) l(t);
+				return;
+			case "enum":
+				e.group.kind === "group" && s(e.group, e.start, e.end);
+				return;
+			case "tagged":
+				if (typeof e.tag == "object") for (let t of e.tag.alternatives) l(t);
+				for (let t of e.item.alternatives) l(t);
+				return;
+			default: return;
+		}
+	};
+	for (let t of e) a.push({
+		node: t,
+		start: t.start,
+		end: t.end,
+		isRule: !0
+	}), c(t.body);
+	let d = [...a].sort((e, t) => e.end - t.end || Number(e.isRule) - Number(t.isRule)), f = [...a].sort((e, t) => e.start - t.start || Number(t.isRule) - Number(e.isRule)), p = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), h = [], g = (e) => {
+		let t = p.get(e);
+		return t || (t = {
+			leading: [],
+			trailing: []
+		}, p.set(e, t)), t;
+	};
+	for (let n of t) {
+		let t;
+		for (let e = d.length - 1; e >= 0; e--) {
+			let r = d[e];
+			if (!(r.end > n.start)) {
+				i(Math.max(r.start, r.end - 1)) === n.line && (t = r);
+				break;
+			}
+		}
+		if (t) {
+			g(t.node).trailing.push(n.text);
+			continue;
+		}
+		let r;
+		for (let e of o) e.start <= n.start && n.end <= e.end && (!r || e.start >= r.start) && (r = e);
+		let a = e.find((e) => e.start <= n.start && n.end <= e.end), s = f.find((e) => e.start >= n.end), c = r !== void 0 && (s === void 0 || s.start > r.end), l = a !== void 0 && (s === void 0 || s.start > a.end);
+		if (s && !c && !l) g(s.node).leading.push(n.text);
+		else if (c) {
+			let e = m.get(r.group) ?? [];
+			e.push(n.text), m.set(r.group, e);
+		} else l ? g(a).trailing.push(n.text) : s ? g(s.node).leading.push(n.text) : h.push(n.text);
+	}
+	return {
+		notes: p,
+		endNotes: m,
+		tail: h
+	};
+}
+var T = (e, t) => e.notes?.get(t) ?? me, _e = (e) => e.trailing.length === 0 ? "" : " " + e.trailing.map((e) => `;${e}`).join(" ");
+function ve(e, t) {
+	let n = T(t, e), r = T(t, e.body), i = e.generics ? `<${e.generics.join(", ")}>` : "", a = `${e.name}${i} ${e.assign}`, o = _e({
+		leading: [],
+		trailing: [...r.trailing, ...n.trailing]
+	}), s, c = n.leading;
+	if (r.leading.length > 0 && t.unit !== null) {
+		let n = t.unit;
+		s = [
+			a,
+			...r.leading.map((e) => `${n};${e}`),
+			`${n}${E(e.body, t, 1)}${o}`
+		].join("\n");
+	} else r.leading.length > 0 && (c = [...c, ...r.leading]), s = `${a} ${E(e.body, t, 0)}${o}`;
+	let l = s.includes("\n");
+	return c.length === 0 ? {
+		text: s,
+		multiline: l
+	} : {
+		text: [...c.map((e) => `;${e}`), s].join("\n"),
+		multiline: l
+	};
+}
+function E(e, t, n) {
+	let r = e.occur ? `${ye(e.occur)} ` : "";
+	return e.kind === "entry-group" ? `${r}${D(e.group, t, n, "(", ")")}` : `${r}${e.memberKey ? `${be(e.memberKey, t, n)} ` : ""}${O(e.value, t, n)}`;
+}
+function ye(e) {
+	return e.marker === "*" ? `${e.min ?? ""}*${e.max ?? ""}` : e.marker;
+}
+function be(e, t, n) {
+	switch (e.kind) {
+		case "bareword": return `${e.key}:`;
+		case "value": return `${e.key.raw}:`;
+		case "type1": return `${xe(e.key, t, n)} ${e.cut ? "^ " : ""}=>`;
+	}
+}
+function D(e, t, n, r, i) {
+	let a = e.choices.reduce((e, t) => e + t.length, 0), o = t.endNotes?.get(e) ?? [], s = o.length > 0 || t.notes !== null && e.choices.some((e) => e.some((e) => t.notes.has(e)));
+	if (!(t.unit !== null && (a > 1 || e.choices.length > 1 || s))) return `${r}${e.choices.map((e) => e.map((e) => E(e, t, n)).join(", ")).join(" // ") + (e.trailingComma ? "," : "")}${i}`;
+	let c = t.unit, l = c.repeat(n + 1), u = [r];
+	e.choices.forEach((r, i) => {
+		i > 0 && u.push(`${l}//`), r.forEach((a, o) => {
+			let s = T(t, a);
+			for (let e of s.leading) u.push(`${l};${e}`);
+			let c = !(i === e.choices.length - 1 && o === r.length - 1) || e.trailingComma ? "," : "";
+			u.push(`${l}${E(a, t, n + 1)}${c}${_e(s)}`);
+		});
+	});
+	for (let e of o) u.push(`${l};${e}`);
+	return u.push(`${c.repeat(n)}${i}`), u.join("\n");
+}
+function O(e, t, n) {
+	return e.alternatives.map((e) => xe(e, t, n)).join(" / ");
+}
+function xe(e, t, n) {
+	let r = Ce(e.target, t, n);
+	if (!e.op || !e.controller) return r;
+	let i = Ce(e.controller, t, n);
+	return e.op.kind === "range" ? `${r}${e.op.inclusive ? ".." : "..."}${i}` : `${r} .${e.op.name} ${i}`;
+}
+function Se(e, t, n) {
+	let r = e.genericArgs ? `<${e.genericArgs.map((e) => xe(e, t, n)).join(", ")}>` : "";
+	return `${e.name}${r}`;
+}
+function Ce(e, t, n) {
+	switch (e.kind) {
+		case "value": return e.raw;
+		case "ref": return Se(e, t, n);
+		case "paren": return `(${O(e.type, t, n)})`;
+		case "map": return D(e.group, t, n, "{", "}");
+		case "array": return D(e.group, t, n, "[", "]");
+		case "unwrap": return `~${Se(e.ref, t, n)}`;
+		case "enum": return e.group.kind === "ref" ? `&${Se(e.group, t, n)}` : `&${D(e.group, t, n, "(", ")")}`;
+		case "tagged": return `${e.raw ?? (typeof e.tag == "object" ? `#6.<${O(e.tag, t, n)}>` : `#6${e.tag === void 0 ? "" : `.${e.tag}`}`)}(${O(e.item, t, n)})`;
+		case "major": return e.raw === void 0 ? typeof e.ai == "object" ? `#${e.major}.<${O(e.ai, t, n)}>` : `#${e.major}${e.ai === void 0 ? "" : `.${e.ai}`}` : e.raw;
+		case "any": return "#";
+	}
+}
+//#endregion
+//#region src/cddl/equal.ts
+function k(e) {
+	if (e instanceof i || e instanceof u) return e.value;
+	if (e instanceof ne || e instanceof f) return e.bigValue;
+}
+function A(e) {
+	if (e instanceof h) return e.value;
+	if (e instanceof l) return e.chunks.map((e) => e.value).join("");
+}
+function j(e) {
+	if (e instanceof t) return e.value;
+	if (e instanceof ee) {
+		let t = e.chunks.map((e) => e.value), n = t.reduce((e, t) => e + t.length, 0), r = new Uint8Array(n), i = 0;
+		for (let e of t) r.set(e, i), i += e.length;
+		return r;
+	}
+	if (e instanceof re) {
+		let t = e.items.map((e) => e.toCBOR()), n = t.reduce((e, t) => e + t.length, 0), r = new Uint8Array(n), i = 0;
+		for (let e of t) r.set(e, i), i += e.length;
+		return r;
+	}
+}
+function we(e, t) {
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+//#endregion
+//#region src/cddl/controls.ts
+var Te = new TextEncoder(), Ee = new TextDecoder("utf-8", { fatal: !0 }), M = (e) => ({
+	kind: "value",
+	raw: "",
+	start: 0,
+	end: 0,
+	...e
+}), De = (e) => {
+	let t = k(e);
+	if (t !== void 0) return t;
+	if (e instanceof s) return e.value;
+}, N = (e) => e.type === "int" || e.type === "float" ? e.value : void 0, Oe = (e, t) => {
+	if (typeof e == "bigint" && typeof t == "bigint") return e < t ? -1 : +(e > t);
+	let n = Number(e), r = Number(t);
+	return n < r ? -1 : n > r ? 1 : n === r ? 0 : NaN;
+}, ke = (e, t, n, r, a, o) => {
+	if (!e.matchType2(t, n, a)) return !1;
+	let s = (n) => e.matchType2(e.uint(n), r, a) ? !0 : e.fail(a, t, o, `size ${n} does not match the .size constraint`), c = A(t);
+	if (c !== void 0) return s(Te.encode(c).length);
+	let l = j(t);
+	if (l !== void 0) return s(l.length);
+	if (t instanceof i) {
+		let n = 0;
+		for (let e = t.value; e > 0n; e >>= 8n) n++;
+		let i = e.existsIntGE(r, BigInt(n));
+		if (i !== void 0) return i ? !0 : e.fail(a, t, o, `${t.value} does not fit the .size constraint`);
+		e.warnOnce(".size controller could not be analyzed; searching a bounded window of byte counts", o);
+		for (let t = n; t <= n + 64; t++) if (e.matchType2(e.uint(t), r, a)) return !0;
+		return e.fail(a, t, o, `${t.value} does not fit the .size constraint`);
+	}
+	return e.fail(a, t, o, ".size applies to strings and unsigned integers");
+}, Ae = (e, t, n, r, a, o) => {
+	if (!e.matchType2(t, n, a)) return !1;
+	let s = [], c = j(t);
+	if (c !== void 0) for (let e = 0; e < c.length; e++) for (let t = 0; t < 8; t++) c[e] & 1 << t && s.push(e * 8 + t);
+	else if (t instanceof i) {
+		let e = t.value;
+		for (let t = 0; e > 0n; t++, e >>= 1n) e & 1n && s.push(t);
+	} else return e.fail(a, t, o, ".bits applies to byte strings and unsigned integers");
+	for (let n of s) if (!e.matchType2(e.uint(n), r, a)) return e.fail(a, t, o, `bit ${n} is set but not allowed by .bits`);
+	return !0;
+}, je = /* @__PURE__ */ new Map(), Me = (e, t, n, r, i, a) => {
+	if (!e.matchType2(t, n, i)) return !1;
+	let o = A(t);
+	if (o === void 0) return e.fail(i, t, a, ".regexp applies to text strings");
+	let s = e.resolveValue(r);
+	if (!s || s.type !== "text") return e.warnOnce(".regexp controller does not resolve to a text string; not checked", a), !0;
+	let c = je.get(s.value);
+	if (c === void 0) {
+		try {
+			c = RegExp(`^(?:${s.value})$`, "u");
+		} catch {
+			c = null;
+		}
+		je.set(s.value, c);
+	}
+	return c === null ? (e.warnOnce(`.regexp pattern is not a valid regular expression here: ${s.value}`, a), !0) : c.test(o) ? !0 : e.fail(i, t, a, `text does not match .regexp ${JSON.stringify(s.value)}`);
+}, Ne = (e) => (t, n, r, i, a, o) => {
+	if (!t.matchType2(n, r, a)) return !1;
+	let s = j(n);
+	if (s === void 0) return t.fail(a, n, o, `.cbor${e ? "seq" : ""} applies to byte strings`);
+	let c;
+	try {
+		if (e) {
+			let e = new Uint8Array(s.length + 2);
+			e[0] = 159, e.set(s, 1), e[e.length - 1] = 255, c = te(e);
+		} else c = te(s);
+	} catch (e) {
+		return t.fail(a, n, o, `byte string does not contain valid CBOR: ${e instanceof Error ? e.message : String(e)}`);
+	}
+	return t.matchEmbedded(c, i, a) ? !0 : t.fail(a, n, o, `embedded CBOR does not match the .cbor${e ? "seq" : ""} type`);
+}, Pe = (e, t, n, r, i, a) => e.matchType2(t, n, i) ? e.matchType2(t, r, i) ? !0 : e.fail(i, t, a, "value does not match the .within/.and constraint") : !1, P = (e) => (t, n, r, i, a, o) => {
+	if (!t.matchType2(n, r, a)) return !1;
+	let s = t.resolveValue(i), c = s && N(s);
+	if (c === void 0) return t.warnOnce(`.${e} controller does not resolve to a number; not checked`, o), !0;
+	let l = De(n);
+	if (l === void 0) return t.fail(a, n, o, `.${e} applies to numbers`);
+	let u = Oe(l, c);
+	return (e === "lt" ? u < 0 : e === "le" ? u <= 0 : e === "gt" ? u > 0 : u >= 0) ? !0 : t.fail(a, n, o, `${l} does not satisfy .${e} ${c}`);
+}, Fe = (e, t, n, r, i, a) => {
+	if (!e.matchType2(t, n, i)) return !1;
+	let o = e.resolveValue(r);
+	return o ? e.matchesLiteral(t, o) ? !0 : e.fail(i, t, a, `value does not equal ${o.raw || ".eq controller"}`) : (e.warnOnce(".eq controller does not resolve to a literal value; not checked", a), !0);
+}, Ie = (e, t, n, r, i, a) => {
+	if (!e.matchType2(t, n, i)) return !1;
+	let o = e.resolveValue(r);
+	return o ? !e.matchesLiteral(t, o) || e.fail(i, t, a, `value must not equal ${o.raw || ".ne controller"}`) : (e.warnOnce(".ne controller does not resolve to a literal value; not checked", a), !0);
+}, Le = (e, t, n, r, i, a) => {
+	if (!e.matchType2(t, n, i)) return !1;
+	let o = e.resolveValue(r);
+	return o ? !e.matchesLiteral(t, o) || e.fail(i, t, a, `value equals the default ${o.raw || "value"} (implied .ne, RFC 8610 §3.8.6)`) : (e.warnOnce(".default controller does not resolve to a literal value; the implied .ne is not checked", a), !0);
+}, Re = (e, t, n, r, i, a) => {
+	let o = e.resolveValue(n), s = e.resolveValue(r), c = o && N(o), l = s && N(s);
+	if (o === void 0 || c === void 0 || l === void 0) return e.warnOnce(".plus operands do not resolve to numbers; not checked", a), e.fail(i, t, a, ".plus could not be computed");
+	if (o.type === "float") {
+		let n = Number(c) + Number(l);
+		return e.matchesLiteral(t, M({
+			type: "float",
+			value: n
+		})) ? !0 : e.fail(i, t, a, `expected ${n} (.plus)`);
+	}
+	if (typeof l == "number" && !Number.isFinite(l)) return e.fail(i, t, a, ".plus controller is not finite");
+	let u = (typeof c == "bigint" ? c : BigInt(c)) + (typeof l == "bigint" ? l : BigInt(Math.floor(l)));
+	return e.matchesLiteral(t, M({
+		type: "int",
+		value: u
+	})) ? !0 : e.fail(i, t, a, `expected ${u} (.plus)`);
+}, ze = (e, t, n, r, i, a) => {
+	let o = e.resolveValue(n), s = e.resolveValue(r), c = (e) => e.type === "text" ? Te.encode(e.value) : e.type === "bytes" ? e.value : void 0, l = o && c(o), u = s && c(s);
+	if (!o || l === void 0 || u === void 0) return e.warnOnce(".cat operands do not resolve to strings; not checked", a), e.fail(i, t, a, ".cat could not be computed");
+	let d = new Uint8Array(l.length + u.length);
+	if (d.set(l, 0), d.set(u, l.length), o.type === "text") {
+		let n;
+		try {
+			n = Ee.decode(d);
+		} catch {
+			return e.fail(i, t, a, ".cat result is not valid UTF-8");
+		}
+		return e.matchesLiteral(t, M({
+			type: "text",
+			value: n
+		})) ? !0 : e.fail(i, t, a, `expected ${JSON.stringify(n)} (.cat)`);
+	}
+	return e.matchesLiteral(t, M({
+		type: "bytes",
+		value: d,
+		qualifier: "h"
+	})) ? !0 : e.fail(i, t, a, "byte string does not equal the .cat result");
+}, Be = (e) => {
+	for (; e.kind === "paren" && e.type.alternatives.length === 1 && !e.type.alternatives[0].op;) e = e.type.alternatives[0].target;
+	return e;
+}, Ve = (e, t) => {
+	let n = Be(t);
+	if (n.kind === "array") {
+		let e = n.group.choices[0]?.[0];
+		if (!e || e.kind !== "entry" || e.value.alternatives.length !== 1 || e.value.alternatives[0].op) return;
+		n = e.value.alternatives[0].target;
+	}
+	let r = e.resolveValue(n);
+	return r?.type === "text" ? r.value : void 0;
+}, He = {
+	size: ke,
+	bits: Ae,
+	regexp: Me,
+	cbor: Ne(!1),
+	cborseq: Ne(!0),
+	within: Pe,
+	and: Pe,
+	lt: P("lt"),
+	le: P("le"),
+	gt: P("gt"),
+	ge: P("ge"),
+	eq: Fe,
+	ne: Ie,
+	default: Le,
+	plus: Re,
+	cat: ze,
+	feature: (e, t, n, r, i, a) => {
+		let o = Ve(e, r);
+		return o === void 0 ? (e.warnOnce(".feature controller does not resolve to a feature name", a), e.fail(i, t, a, "unresolvable .feature")) : e.features.has(o) ? e.matchType2(t, n, i) : (e.warnOnce(`feature "${o}" is not enabled (pass it in options.features to accept it)`, a), e.fail(i, t, a, `feature "${o}" is not enabled`));
+	}
+};
+function Ue(e) {
+	return Object.prototype.hasOwnProperty.call(He, e) ? He[e] : void 0;
+}
+//#endregion
+//#region src/cddl/validator.ts
+var We = class extends Error {}, Ge = class {
+	schema;
+	maxDepth;
+	maxSteps;
+	features;
+	steps = 0;
+	ruleName;
+	embeddedDepth = 0;
+	preludeDepth = 0;
+	preludeRef;
+	warnings = [];
+	warned = /* @__PURE__ */ new Set();
+	best;
+	constructor(e, t, n, r) {
+		this.schema = e, this.maxDepth = t, this.maxSteps = n, this.features = r;
+	}
+	step() {
+		if (++this.steps > this.maxSteps) throw new We(`validation aborted: step budget of ${this.maxSteps} exceeded (pathological backtracking?)`);
+	}
+	checkDepth(e) {
+		if (e > this.maxDepth) throw new We(`validation aborted: recursion depth ${this.maxDepth} exceeded (cyclic rules without progress?)`);
+	}
+	warnOnce(e, t) {
+		let n = `${e}@${t?.start ?? -1}`;
+		this.warned.has(n) || (this.warned.add(n), this.warnings.push({
+			message: e,
+			...t ? {
+				schemaStart: t.start,
+				schemaEnd: t.end
+			} : {}
+		}));
+	}
+	fail(e, t, n, r) {
+		let i = this.embeddedDepth > 0, a = i ? -1 : t?.start ?? -1;
+		if (!this.best || a > this.best.startKey || a === this.best.startKey && e.length >= this.best.depth) {
+			let o = this.preludeDepth > 0 ? this.preludeRef : n;
+			this.best = {
+				depth: e.length,
+				startKey: a,
+				message: r,
+				path: e.length === 0 ? "/" : "/" + e.join("/"),
+				...!i && t?.start !== void 0 ? {
+					start: t.start,
+					end: t.end
+				} : {},
+				...this.ruleName === void 0 ? {} : { ruleName: this.ruleName },
+				...o ? {
+					schemaStart: o.start,
+					schemaEnd: o.end
+				} : {}
+			};
+		}
+		return !1;
+	}
+};
+function Ke(e, t, n) {
+	let r = n?.rule ?? e.root?.name;
+	if (r === void 0) return {
+		valid: !1,
+		errors: [{
+			message: "schema has no rules (no root to validate against)",
+			path: "/"
+		}]
+	};
+	let i = new Ge(e, n?.maxDepth ?? 256, n?.maxSteps ?? 1e6, new Set(n?.features ?? [])), a = F(i, r)?.[0]?.generics?.length ?? 0;
+	if (a > 0) return {
+		valid: !1,
+		errors: [{
+			message: `rule '${r}' takes ${a} generic argument${a === 1 ? "" : "s"} and cannot be used as a validation target directly; reference it with concrete arguments from another rule instead`,
+			path: "/"
+		}]
+	};
+	let o;
+	try {
+		o = Ye(t, r, void 0, [], i, 0);
+	} catch (e) {
+		if (!(e instanceof We)) throw e;
+		return {
+			valid: !1,
+			errors: [{
+				message: e.message,
+				path: "/"
+			}],
+			...i.warnings.length ? { warnings: i.warnings } : {}
+		};
+	}
+	return o ? {
+		valid: !0,
+		errors: [],
+		...i.warnings.length ? { warnings: i.warnings } : {}
+	} : {
+		valid: !1,
+		errors: i.best ? [(({ depth: e, startKey: t, ...n }) => n)(i.best)] : [{
+			message: `value does not match rule '${r}'`,
+			path: "/",
+			...t.start === void 0 ? {} : {
+				start: t.start,
+				end: t.end
+			}
+		}],
+		...i.warnings.length ? { warnings: i.warnings } : {}
+	};
+}
+function F(e, t) {
+	let n = e.schema.rules.get(t);
+	if (n) return n;
+	let r = w().get(t);
+	return r ? [r] : void 0;
+}
+function I(e) {
+	return e.kind === "entry" && !e.occur && !e.memberKey;
+}
+function qe(e) {
+	return e.kind === "entry-group" && !e.occur ? e.group.choices : [[e]];
+}
+function Je(e) {
+	return e.some((e) => !I(e.body));
+}
+function L(e, t, n) {
+	let r = e.generics;
+	if (!r || !t) return;
+	let i = /* @__PURE__ */ new Map();
+	for (let e = 0; e < r.length && e < t.length; e++) i.set(r[e], {
+		type1: t[e],
+		env: n
+	});
+	return i;
+}
+function Ye(e, t, n, r, i, a, o, s) {
+	let c = F(i, t);
+	if (!c) return i.fail(r, e, o, t.startsWith("$") ? `socket '${t}' has no definitions, so nothing matches it` : `'${t}' is not defined`);
+	i.checkDepth(a);
+	let l = i.ruleName;
+	i.ruleName = t;
+	let u = !i.schema.rules.has(t);
+	u && ++i.preludeDepth === 1 && (i.preludeRef = o);
+	try {
+		for (let o of c) {
+			let c = L(o, s, n);
+			if (I(o.body)) {
+				if (R(e, o.body.value, c, r, i, a + 1)) return !0;
+				continue;
+			}
+			let l = qe(o.body), u = !0;
+			for (let e of l) if (!(e.length === 1 && I(e[0]))) {
+				u = !1;
+				break;
+			}
+			if (!u) {
+				i.fail(r, e, o.body, `group rule '${t}' cannot be used as a type`);
+				continue;
+			}
+			for (let t of l) {
+				let n = t[0];
+				if (R(e, n.value, c, r, i, a + 1)) return !0;
+			}
+		}
+		return !1;
+	} finally {
+		i.ruleName = l, u && --i.preludeDepth === 0 && (i.preludeRef = void 0);
+	}
+}
+function Xe(e) {
+	for (; e instanceof p;) e = e.inner;
+	return e;
+}
+function R(e, t, n, r, i, a) {
+	for (let o of t.alternatives) if (z(e, o, n, r, i, a)) return !0;
+	return !1;
+}
+function z(e, t, n, r, i, a) {
+	if (i.step(), e = Xe(e), !t.op || !t.controller) return B(e, t.target, n, r, i, a);
+	if (t.op.kind === "range") return it(e, t, n, r, i, a);
+	let o = Ue(t.op.name), s = Ct(n, i, a);
+	return o ? o(s, e, t.target, t.controller, r, t) : (i.warnOnce(`control operator .${t.op.name} is not supported; matching the target only`, t), B(e, t.target, n, r, i, a));
+}
+function B(e, t, a, o, s, c) {
+	if (e = Xe(e), e instanceof _) return !0;
+	switch (t.kind) {
+		case "any": return !0;
+		case "value": return H(e, t) ? !0 : s.fail(o, e, t, `expected the value ${t.raw}`);
+		case "ref": {
+			let n = a?.get(t.name);
+			return n && !t.genericArgs ? z(e, n.type1, n.env, o, s, c + 1) : Ye(e, t.name, a, o, s, c + 1, t, t.genericArgs);
+		}
+		case "paren": return R(e, t.type, a, o, s, c);
+		case "map": return e instanceof r ? _t(e, t.group, a, o, s, c + 1) : s.fail(o, e, t, "expected a map");
+		case "array": return e instanceof n ? pt(e, t.group, a, o, s, c + 1) : s.fail(o, e, t, "expected an array");
+		case "tagged":
+			if (!(e instanceof g)) return s.fail(o, e, t, "expected a tagged item");
+			if (typeof t.tag == "bigint") {
+				if (e.tag !== t.tag) return s.fail(o, e, t, `expected tag ${t.tag}, got ${e.tag}`);
+			} else if (t.tag !== void 0 && !R(new i(e.tag), t.tag, a, o, s, c + 1)) return s.fail(o, e, t, `tag number ${e.tag} does not match the head type`);
+			return R(e.content, t.item, a, o, s, c + 1);
+		case "major": return ot(e, t, a, o, s, c);
+		case "unwrap": {
+			let n = dt(t.ref, a, s, 0);
+			return n ? R(e, n.type, n.env, o, s, c + 1) : (s.warnOnce(`~${t.ref.name} is used outside of an array/map group context`, t), s.fail(o, e, t, `~${t.ref.name} cannot match here`));
+		}
+		case "enum": {
+			let n = t.group.kind === "ref" ? X(t.group, a, s) : Y(t.group, a);
+			return n ? (s.checkDepth(c), V(e, n, o, s, c + 1) ? !0 : s.fail(o, e, t, "no enumeration value matches")) : s.fail(o, e, t, "'&' target does not resolve to a group");
+		}
+	}
+}
+function V(e, t, n, r, i) {
+	for (let { entries: a, env: o } of t) for (let t of a) {
+		if (r.step(), t.kind === "entry-group") {
+			if (V(e, Y(t.group, o), n, r, i + 1)) return !0;
+			continue;
+		}
+		let a = lt(t, o, r);
+		if (a) {
+			if (r.checkDepth(i), V(e, a, n, r, i + 1)) return !0;
+			continue;
+		}
+		if (R(e, t.value, o, n, r, i + 1)) return !0;
+	}
+	return !1;
+}
+function H(e, t) {
+	switch (t.type) {
+		case "int": return k(e) === BigInt(t.value);
+		case "float": return e instanceof s && (e.value === t.value || Number.isNaN(e.value) && Number.isNaN(t.value));
+		case "text": return A(e) === t.value;
+		case "bytes": {
+			let n = j(e);
+			return n !== void 0 && we(n, t.value);
+		}
+	}
+}
+function U(e, t, n, r = 0) {
+	if (r > 32) return;
+	if (e.kind === "value") return e;
+	if (e.kind === "paren") {
+		let i = e.type.alternatives.length === 1 ? e.type.alternatives[0] : void 0;
+		return !i || i.op ? void 0 : U(i.target, t, n, r + 1);
+	}
+	if (e.kind !== "ref") return;
+	let i = t?.get(e.name);
+	if (i && !e.genericArgs) return i.type1.op ? void 0 : U(i.type1.target, i.env, n, r + 1);
+	let a = F(n, e.name);
+	if (!a || a.length !== 1) return;
+	let o = a[0].body;
+	if (!I(o) || o.value.alternatives.length !== 1) return;
+	let s = o.value.alternatives[0];
+	if (s.op) return;
+	let c = L(a[0], e.genericArgs, t);
+	return U(s.target, c, n, r + 1);
+}
+function Ze(e, t, n, r, i = 0) {
+	return Qe(e, t, void 0, n, r, i);
+}
+function Qe(e, t, n, r, i, a = 0) {
+	let o = W(e, t, n, r, i, a);
+	return o === void 0 ? void 0 : o !== null;
+}
+function W(e, t, n, r, i, a = 0) {
+	if (n !== void 0 && t > n) return null;
+	if (!(a > 32)) switch (e.kind) {
+		case "value":
+			if (e.type === "int") {
+				let r = BigInt(e.value);
+				return r >= t && (n === void 0 || r <= n) ? r : null;
+			}
+			return null;
+		case "any": {
+			let e = t > 0n ? t : 0n;
+			return n === void 0 || e <= n ? e : null;
+		}
+		case "major":
+			if (e.ai !== void 0) return;
+			if (e.major === 0) {
+				let e = t > 0n ? t : 0n;
+				return e <= 18446744073709551615n && (n === void 0 || e <= n) ? e : null;
+			}
+			if (e.major === 1) {
+				let e = t > -18446744073709551616n ? t : -18446744073709551616n;
+				return e <= -1n && (n === void 0 || e <= n) ? e : null;
+			}
+			return null;
+		case "paren": return G(e.type, t, n, r, i, a + 1);
+		case "ref": {
+			let o = r?.get(e.name);
+			if (o && !e.genericArgs) return $e(o.type1, t, n, o.env, i, a + 1);
+			let s = F(i, e.name);
+			if (!s) return;
+			let c = !1, l = null;
+			for (let o of s) {
+				if (!I(o.body)) {
+					c = !0;
+					continue;
+				}
+				let s = L(o, e.genericArgs, r), u = G(o.body.value, t, n, s, i, a + 1);
+				typeof u == "bigint" && (l === null || u < l) && (l = u), u === void 0 && (c = !0);
+			}
+			return l ?? (c ? void 0 : null);
+		}
+		case "enum": {
+			let o = e.group.kind === "ref" ? X(e.group, r, i) : Y(e.group, r);
+			if (!o) return;
+			let s = !1, c = null;
+			for (let { entries: e, env: r } of o) for (let o of e) {
+				if (o.kind !== "entry") {
+					s = !0;
+					continue;
+				}
+				let e = G(o.value, t, n, r, i, a + 1);
+				typeof e == "bigint" && (c === null || e < c) && (c = e), e === void 0 && (s = !0);
+			}
+			return c ?? (s ? void 0 : null);
+		}
+		default: return;
+	}
+}
+function G(e, t, n, r, i, a) {
+	let o = !1, s = null;
+	for (let c of e.alternatives) {
+		let e = $e(c, t, n, r, i, a);
+		typeof e == "bigint" && (s === null || e < s) && (s = e), e === void 0 && (o = !0);
+	}
+	return s ?? (o ? void 0 : null);
+}
+function $e(e, t, n, r, i, a) {
+	if (!e.op) return W(e.target, t, n, r, i, a);
+	if (e.op.kind === "ctl") {
+		if (e.op.name === "bits") return tt(e.target, e.controller, t, n, r, i, a + 1);
+		if (e.op.name === "size") {
+			let o = W(e.target, t > 0n ? t : 0n, n, r, i, a + 1);
+			if (o == null) return o;
+			let s = Ze(e.controller, BigInt(rt(o)), r, i, a + 1);
+			return s === void 0 ? void 0 : s ? o : null;
+		}
+		if (e.op.name === "feature") {
+			let o = Ve(Ct(r, i, a), e.controller);
+			return o === void 0 ? void 0 : i.features.has(o) ? W(e.target, t, n, r, i, a + 1) : (i.warnOnce(`feature "${o}" is not enabled (pass it in options.features to accept it)`, e), null);
+		}
+		if (e.op.name === "and" || e.op.name === "within") return et(e.target, e.controller, t, n, r, i, a + 1);
+		if (e.op.name === "plus") {
+			let a = U(e.target, r, i), o = U(e.controller, r, i);
+			if (!a || !o || a.type === "text" || a.type === "bytes" || o.type === "text" || o.type === "bytes") return;
+			if (a.type === "float") return null;
+			let s = o.type === "int" ? BigInt(a.value) + BigInt(o.value) : BigInt(Math.floor(Number(a.value) + o.value));
+			return s >= t && (n === void 0 || s <= n) ? s : null;
+		}
+		let o = U(e.controller, r, i);
+		if (!o || o.type !== "int") return;
+		let s = BigInt(o.value);
+		switch (e.op.name) {
+			case "eq": return W(e.target, s > t ? s : t, n === void 0 || s < n ? s : n, r, i, a + 1);
+			case "ne":
+			case "default": {
+				let o = W(e.target, t, n === void 0 || s - 1n < n ? s - 1n : n, r, i, a + 1);
+				if (typeof o == "bigint") return o;
+				let c = W(e.target, s + 1n > t ? s + 1n : t, n, r, i, a + 1);
+				return typeof c == "bigint" ? c : o === void 0 || c === void 0 ? void 0 : null;
+			}
+			case "lt":
+			case "le": {
+				let o = s - (e.op.name === "lt" ? 1n : 0n);
+				return W(e.target, t, n === void 0 || o < n ? o : n, r, i, a + 1);
+			}
+			case "gt":
+			case "ge": {
+				let o = s + (e.op.name === "gt" ? 1n : 0n);
+				return W(e.target, o > t ? o : t, n, r, i, a + 1);
+			}
+			default: return;
+		}
+	}
+	let o = U(e.target, r, i), s = U(e.controller, r, i);
+	if (!o || !s || o.type !== "int" || s.type !== "int") return;
+	let c = BigInt(o.value), l = BigInt(s.value) - (e.op.inclusive ? 0n : 1n), u = c > t ? c : t;
+	return u <= (n === void 0 || l < n ? l : n) ? u : null;
+}
+function et(e, t, n, r, i, a, o) {
+	let s = n;
+	for (let n = 0; n < 256; n++) {
+		let n = W(e, s, r, i, a, o + 1), c = W(t, s, r, i, a, o + 1);
+		if (n === null || c === null) return null;
+		if (n === void 0 || c === void 0) return;
+		if (n === c) return n;
+		s = n > c ? n : c;
+	}
+}
+function tt(e, t, n, r, i, a, o) {
+	let s = 0n;
+	for (let e = 0; e < 64; e++) {
+		let n = W(t, BigInt(e), BigInt(e), i, a, o + 1);
+		if (n === void 0) return;
+		n !== null && (s |= 1n << BigInt(e));
+	}
+	let c = n > 0n ? n : 0n, l = r === void 0 || r > 18446744073709551615n ? 18446744073709551615n : r;
+	for (let t = 0; t < 256; t++) {
+		let t = W(e, c, l, i, a, o + 1), n = nt(c, l, s);
+		if (t === void 0) return;
+		if (t === null || n === null) return null;
+		if (t === n) return t;
+		c = t > n ? t : n;
+	}
+}
+function nt(e, t, n) {
+	if (e < 0n && (e = 0n), e > t) return null;
+	let r = (i, a, o) => {
+		if (i < 0) return o <= t ? o : null;
+		let s = Number(e >> BigInt(i) & 1n);
+		for (let e = 0; e <= 1; e++) {
+			if (e === 1 && (n & 1n << BigInt(i)) == 0n || !a && e < s) continue;
+			let t = r(i - 1, a || e > s, e === 1 ? o | 1n << BigInt(i) : o);
+			if (t !== null) return t;
+		}
+		return null;
+	};
+	return r(63, !1, 0n);
+}
+function rt(e) {
+	let t = 0;
+	for (let n = e; n > 0n; n >>= 8n) t++;
+	return t;
+}
+function it(e, t, n, r, i, a) {
+	let o = t.op, c = U(t.target, n, i), l = U(t.controller, n, i);
+	if (!c || !l) return i.warnOnce("range endpoints do not resolve to literal values", t), i.fail(r, e, t, "unresolvable range");
+	if (c.type === "int" && l.type === "int") {
+		let n = k(e);
+		if (n === void 0) return i.fail(r, e, t, `expected an integer in ${K(t)}`);
+		let a = BigInt(c.value), s = BigInt(l.value);
+		return n >= a && (o.inclusive ? n <= s : n < s) || i.fail(r, e, t, `${n} is outside ${K(t)}`);
+	}
+	if (c.type === "float" && l.type === "float") {
+		if (!(e instanceof s)) return i.fail(r, e, t, `expected a float in ${K(t)}`);
+		let n = e.value;
+		return n >= c.value && (o.inclusive ? n <= l.value : n < l.value) || i.fail(r, e, t, `${n} is outside ${K(t)}`);
+	}
+	return i.warnOnce("range endpoints mix integer and float types", t), i.fail(r, e, t, "invalid range");
+}
+function K(e) {
+	let t = e.op;
+	return `${q(e.target)}${t.inclusive ? ".." : "..."}${q(e.controller)}`;
+}
+function q(e) {
+	return e.kind === "value" ? e.raw : e.kind === "ref" ? e.name : "…";
+}
+var at = {
+	half: 25n,
+	single: 26n,
+	double: 27n
+};
+function ot(e, t, a, c, l, f) {
+	let p = (e) => t.ai === void 0 ? !0 : typeof t.ai == "bigint" ? t.ai === e : R(new i(e), t.ai, a, c, l, f + 1), m = (n) => l.fail(c, e, t, `expected ${n} (#${t.major})`);
+	switch (t.major) {
+		case 0:
+			if (!(e instanceof i)) return m("an unsigned integer");
+			break;
+		case 1:
+			if (!(e instanceof u)) return m("a negative integer");
+			break;
+		case 2:
+			if (j(e) === void 0) return m("a byte string");
+			break;
+		case 3:
+			if (A(e) === void 0) return m("a text string");
+			break;
+		case 4:
+			if (!(e instanceof n)) return m("an array");
+			break;
+		case 5:
+			if (!(e instanceof r)) return m("a map");
+			break;
+		case 6: return e instanceof g ? p(e.tag) ? !0 : l.fail(c, e, t, `tag ${e.tag} does not match ${J(t)}`) : m("a tagged item");
+		case 7: return e instanceof d ? p(BigInt(e.value)) ? !0 : l.fail(c, e, t, `simple(${e.value}) does not match ${J(t)}`) : e instanceof s ? t.ai === void 0 || p(at[e.precision ?? o(e.value)]) ? !0 : l.fail(c, e, t, `float does not match ${J(t)}`) : m("a simple value or float");
+		default: return l.fail(c, e, t, `#${t.major} is not a valid major type`);
+	}
+	return t.ai !== void 0 && t.major <= 5 && l.warnOnce(`the additional-information constraint ${J(t)} is not checked (encoding-level)`, t), !0;
+}
+function J(e) {
+	return e.raw ?? `#${e.major}`;
+}
+var Y = (e, t) => e.choices.map((e) => ({
+	entries: e,
+	env: t
+})), st = {
+	min: 1,
+	max: 1
+};
+function ct(e) {
+	let t = e.occur;
+	return t ? t.marker === "?" ? {
+		min: 0,
+		max: 1
+	} : t.marker === "+" ? {
+		min: 1,
+		max: Infinity
+	} : {
+		min: t.min ?? 0,
+		max: t.max ?? Infinity
+	} : st;
+}
+function X(e, t, n) {
+	let r = F(n, e.name);
+	if (!r || !Je(r)) return;
+	let i = [];
+	for (let n of r) {
+		let r = L(n, e.genericArgs, t);
+		for (let e of qe(n.body)) i.push({
+			entries: e,
+			env: r
+		});
+	}
+	return i;
+}
+function lt(e, t, n) {
+	if (e.kind !== "entry" || e.memberKey || e.value.alternatives.length !== 1) return;
+	let r = e.value.alternatives[0];
+	if (r.op) return;
+	let i = r.target;
+	if (i.kind === "ref") return t?.has(i.name) && !i.genericArgs ? void 0 : X(i, t, n) || (i.name.startsWith("$$") && !F(n, i.name) ? [] : void 0);
+	if (i.kind === "unwrap") return ut(i.ref, t, n, 0);
+}
+function ut(e, t, n, r) {
+	if (r > 32) return;
+	let i = F(n, e.name);
+	if (!i || i.length !== 1) return;
+	let a = i[0].body, o = L(i[0], e.genericArgs, t);
+	if (!I(a)) return qe(a).map((e) => ({
+		entries: e,
+		env: o
+	}));
+	if (a.value.alternatives.length !== 1) return;
+	let s = a.value.alternatives[0];
+	if (!s.op) {
+		if (s.target.kind === "map" || s.target.kind === "array") return Y(s.target.group, o);
+		if (s.target.kind === "ref") return ut(s.target, o, n, r + 1);
+	}
+}
+function dt(e, t, n, r) {
+	if (r > 32) return;
+	let i = F(n, e.name);
+	if (!i || i.length !== 1) return;
+	let a = i[0].body;
+	if (!I(a) || a.value.alternatives.length !== 1) return;
+	let o = a.value.alternatives[0];
+	if (o.op) return;
+	let s = L(i[0], e.genericArgs, t);
+	if (o.target.kind === "tagged") return {
+		type: o.target.item,
+		env: s
+	};
+	if (o.target.kind === "ref") return dt(o.target, s, n, r + 1);
+}
+function ft(e, t, n) {
+	let r = ct(e);
+	if (e.kind === "entry-group") return {
+		kind: "group",
+		occur: r,
+		choices: Y(e.group, t),
+		node: e
+	};
+	let i = lt(e, t, n);
+	return i ? {
+		kind: "group",
+		occur: r,
+		choices: i,
+		node: e
+	} : {
+		kind: "type",
+		occur: r,
+		...e.memberKey ? { memberKey: e.memberKey } : {},
+		type: e.value,
+		env: t,
+		node: e
+	};
+}
+function pt(e, t, n, r, i, a) {
+	return i.checkDepth(a), mt(e.items, 0, Y(t, n), r, i, a).has(e.items.length) ? !0 : i.fail(r, e, t, `array of ${e.items.length} item(s) does not match the group`);
+}
+function mt(e, t, n, r, i, a) {
+	let o = /* @__PURE__ */ new Set();
+	for (let s of n) ht(e, t, s.entries.map((e) => ft(e, s.env, i)), 0, r, i, a, o);
+	return o;
+}
+function ht(e, t, n, r, i, a, o, s) {
+	if (r === n.length) {
+		s.add(t);
+		return;
+	}
+	let c = n[r], l = (t, u) => {
+		if (a.step(), t >= c.occur.min && ht(e, u, n, r + 1, i, a, o, s), !(t >= c.occur.max || u >= e.length)) for (let n of gt(e, u, c, i, a, o)) n !== u && l(t + 1, n);
+	};
+	l(0, t);
+}
+function gt(e, t, n, r, i, a) {
+	return n.kind === "type" ? R(e[t], n.type, n.env, [...r, t], i, a) ? [t + 1] : [] : (i.checkDepth(a), [...mt(e, t, n.choices, r, i, a + 1)].sort((e, t) => t - e));
+}
+function _t(e, t, n, r, i, a) {
+	i.checkDepth(a);
+	let o = Array(e.entries.length).fill(!1);
+	for (let s of Y(t, n)) if (o.fill(!1), Z(e, s.entries, 0, o, s.env, r, i, a, () => vt(e, o, r, i, t))) return !0;
+	return !1;
+}
+function vt(e, t, n, r, i) {
+	for (let a = 0; a < t.length; a++) {
+		if (t[a]) continue;
+		let [o, s] = e.entries[a];
+		if (!(o instanceof _)) return r.fail([...n, xt(o, a)], s, i, `entry ${St(o)} is not allowed by the group`), !1;
+	}
+	return !0;
+}
+function Z(e, t, n, r, i, a, o, s, c) {
+	if (n === t.length) return c();
+	let l = ft(t[n], i, o);
+	if (l.kind === "type") {
+		if (!l.memberKey) return o.fail(a, e, l.node, "group entry without a member key cannot match a map entry");
+		let u = 0;
+		for (let t = 0; t < e.entries.length && u < l.occur.max; t++) {
+			if (r[t]) continue;
+			let [n, i] = e.entries[t];
+			if (!yt(l.memberKey, n, l.env, a, o, s)) continue;
+			let c = [...a, xt(n, t)];
+			if (R(i, l.type, l.env, c, o, s + 1)) {
+				r[t] = !0, u++;
+				continue;
+			}
+			if (l.memberKey.cut) return o.fail(c, i, l.node, `value for ${bt(l.memberKey)} does not match`);
+		}
+		return u < l.occur.min ? o.fail(a, e, l.node, `missing required entry ${bt(l.memberKey)}`) : Z(e, t, n + 1, r, i, a, o, s, c);
+	}
+	o.checkDepth(s);
+	let u = () => {
+		let e = 0;
+		for (let t of r) t && e++;
+		return e;
+	}, d = (f) => {
+		if (o.step(), f >= l.occur.min && Z(e, t, n + 1, r, i, a, o, s, c)) return !0;
+		if (f >= l.occur.max) return !1;
+		let p = r.slice(), m = u();
+		for (let h of l.choices) {
+			if (Z(e, h.entries, 0, r, h.env, a, o, s + 1, () => u() === m ? Z(e, t, n + 1, r, i, a, o, s, c) : d(f + 1))) return !0;
+			for (let e = 0; e < r.length; e++) r[e] = p[e];
+		}
+		return !1;
+	};
+	return d(0);
+}
+function yt(e, t, n, r, i, a) {
+	if (t = Xe(t), t instanceof _) return !0;
+	switch (e.kind) {
+		case "bareword": return A(t) === e.key;
+		case "value": return H(t, e.key);
+		case "type1": return z(t, e.key, n, r, i, a + 1);
+	}
+}
+function bt(e) {
+	switch (e.kind) {
+		case "bareword": return `'${e.key}'`;
+		case "value": return e.key.raw;
+		case "type1": return q(e.key.target);
+	}
+}
+function xt(e, t) {
+	let n = A(e);
+	if (n !== void 0) return n;
+	if (e instanceof i || e instanceof u) {
+		let t = e.value;
+		if (t >= BigInt(-(2 ** 53 - 1)) && t <= BigInt(2 ** 53 - 1)) return Number(t);
+	}
+	return t;
+}
+function St(e) {
+	let t = A(e);
+	return t === void 0 ? e instanceof i || e instanceof u ? e.value.toString() : e.constructor.name.replace(/^Cbor/, "").toLowerCase() : JSON.stringify(t);
+}
+function Ct(e, t, n) {
+	return {
+		matchType2: (r, i, a) => B(r, i, e, a, t, n + 1),
+		matchEmbedded: (r, i, a) => {
+			t.embeddedDepth++;
+			try {
+				return B(r, i, e, a, t, n + 1);
+			} finally {
+				t.embeddedDepth--;
+			}
+		},
+		resolveValue: (n) => U(n, e, t),
+		existsIntGE: (n, r) => Ze(n, r, e, t),
+		matchesLiteral: H,
+		fail: (e, n, r, i) => t.fail(e, n, r, i),
+		warnOnce: (e, n) => t.warnOnce(e, n),
+		features: t.features,
+		uint: (e) => new i(e)
+	};
+}
+//#endregion
+//#region src/cddl/schema.ts
+var wt = class {
+	source;
+	comments;
+	ast;
+	rules;
+	root;
+	warnings;
+	constructor(e, t, n, r, i, a) {
+		this.source = e, this.comments = t, this.ast = n, this.rules = r, i && (this.root = i), a.length > 0 && (this.warnings = a);
+	}
+	format(e) {
+		return he(this.ast, {
+			...e,
+			source: this.source,
+			comments: this.comments
+		});
+	}
+	validate(e, t) {
+		let n = e instanceof a ? e : typeof e == "string" ? m(e) : te(e);
+		return Ke(this, n, t);
+	}
+};
+function Tt(e, t) {
+	let { rules: n, comments: r } = S(e), i = [], a = w();
+	n.length === 0 && i.push({
+		code: "no-rules",
+		message: "a CDDL data model needs at least one rule to provide the root of the definition"
+	});
+	let o = /* @__PURE__ */ new Map();
+	for (let e of n) {
+		let t = o.get(e.name);
+		if (!t) {
+			o.set(e.name, [e]);
+			continue;
+		}
+		e.assign === "=" && i.push({
+			code: "duplicate-rule",
+			message: `rule '${e.name}' is already defined; use /= or //= to extend it`,
+			start: e.start,
+			end: e.end
+		}), t.push(e);
+	}
+	let s = (e) => {
+		let t = o.get(e);
+		if (t) return t[0].generics?.length ?? 0;
+		let n = a.get(e);
+		if (n) return n.generics?.length ?? 0;
+	};
+	for (let e of n) {
+		let t = e.generics;
+		Dt(e.body, {
+			onRef(e) {
+				if (t?.includes(e.name) || e.name.startsWith("$")) return;
+				let n = s(e.name);
+				if (n === void 0) {
+					i.push({
+						code: "undefined-name",
+						message: `'${e.name}' is not defined (and is not a prelude name)`,
+						start: e.start,
+						end: e.end
+					});
+					return;
+				}
+				let r = e.genericArgs?.length ?? 0;
+				n !== r && i.push({
+					code: "generic-arity",
+					message: `'${e.name}' takes ${n} generic argument${n === 1 ? "" : "s"} but is used with ${r}`,
+					start: e.start,
+					end: e.end
+				});
+			},
+			onMajor(e, t, n) {
+				e > 7 && i.push({
+					code: "invalid-major",
+					message: `#${e} is not a CBOR major type (0–7)`,
+					start: t,
+					end: n
+				});
+			}
+		});
+	}
+	let c = n[0];
+	if (c && !Et(c.body) && i.push({
+		code: "invalid-root",
+		message: `the first rule '${c.name}' is the root of the data model and must define a type, not a group (RFC 8610 §2.2.4)`,
+		start: c.start,
+		end: c.end
+	}), (t?.strict ?? !0) && i.length > 0) throw new oe(i);
+	return new wt(e, r, n, o, c, i);
+}
+function Et(e) {
+	if (e.kind === "entry") return !e.occur && !e.memberKey;
+	if (e.occur || e.group.trailingComma) return !1;
+	let { choices: t } = e.group;
+	return t.length === 1 && t[0].length === 1 && Et(t[0][0]);
+}
+function Dt(e, t) {
+	if (e.kind === "entry-group") {
+		Ot(e.group, t);
+		return;
+	}
+	e.memberKey?.kind === "type1" && $(e.memberKey.key, t), Q(e.value, t);
+}
+function Ot(e, t) {
+	for (let n of e.choices) for (let e of n) Dt(e, t);
+}
+function Q(e, t) {
+	for (let n of e.alternatives) $(n, t);
+}
+function $(e, t) {
+	kt(e.target, t), e.controller && kt(e.controller, t);
+}
+function kt(e, t) {
+	switch (e.kind) {
+		case "value":
+		case "any": return;
+		case "ref":
+			t.onRef(e);
+			for (let n of e.genericArgs ?? []) $(n, t);
+			return;
+		case "paren":
+			Q(e.type, t);
+			return;
+		case "map":
+		case "array":
+			Ot(e.group, t);
+			return;
+		case "unwrap":
+			t.onRef(e.ref);
+			for (let n of e.ref.genericArgs ?? []) $(n, t);
+			return;
+		case "enum":
+			if (e.group.kind === "ref") {
+				t.onRef(e.group);
+				for (let n of e.group.genericArgs ?? []) $(n, t);
+			} else Ot(e.group, t);
+			return;
+		case "tagged":
+			typeof e.tag == "object" && Q(e.tag, t), Q(e.item, t);
+			return;
+		case "major":
+			t.onMajor(e.major, e.start, e.end), typeof e.ai == "object" && Q(e.ai, t);
+			return;
+	}
+}
+//#endregion
+export { S as a, oe as c, w as i, v as l, Tt as n, le as o, pe as r, ae as s, wt as t };
+
+//# sourceMappingURL=schema-Bofmsptw.js.map