@bcts/dcbor-parse 1.0.0-alpha.13

package/dist/index.mjs

@@ -0,0 +1,1118 @@
+import { CborDate, CborMap, cbor, getGlobalTagsStore } from "@bcts/dcbor";
+import { KNOWN_VALUES, KnownValue } from "@bcts/known-values";
+import { UR } from "@bcts/uniform-resources";
+
+//#region src/error.ts
+/**
+* Creates a span with the given start and end positions.
+*/
+function span(start, end) {
+	return {
+		start,
+		end
+	};
+}
+/**
+* Creates a default (empty) span.
+*/
+function defaultSpan() {
+	return {
+		start: 0,
+		end: 0
+	};
+}
+const parseError = {
+	emptyInput() {
+		return { type: "EmptyInput" };
+	},
+	unexpectedEndOfInput() {
+		return { type: "UnexpectedEndOfInput" };
+	},
+	extraData(span$1) {
+		return {
+			type: "ExtraData",
+			span: span$1
+		};
+	},
+	unexpectedToken(token$1, span$1) {
+		return {
+			type: "UnexpectedToken",
+			token: token$1,
+			span: span$1
+		};
+	},
+	unrecognizedToken(span$1) {
+		return {
+			type: "UnrecognizedToken",
+			span: span$1
+		};
+	},
+	expectedComma(span$1) {
+		return {
+			type: "ExpectedComma",
+			span: span$1
+		};
+	},
+	expectedColon(span$1) {
+		return {
+			type: "ExpectedColon",
+			span: span$1
+		};
+	},
+	unmatchedParentheses(span$1) {
+		return {
+			type: "UnmatchedParentheses",
+			span: span$1
+		};
+	},
+	unmatchedBraces(span$1) {
+		return {
+			type: "UnmatchedBraces",
+			span: span$1
+		};
+	},
+	expectedMapKey(span$1) {
+		return {
+			type: "ExpectedMapKey",
+			span: span$1
+		};
+	},
+	invalidTagValue(value, span$1) {
+		return {
+			type: "InvalidTagValue",
+			value,
+			span: span$1
+		};
+	},
+	unknownTagName(name, span$1) {
+		return {
+			type: "UnknownTagName",
+			name,
+			span: span$1
+		};
+	},
+	invalidHexString(span$1) {
+		return {
+			type: "InvalidHexString",
+			span: span$1
+		};
+	},
+	invalidBase64String(span$1) {
+		return {
+			type: "InvalidBase64String",
+			span: span$1
+		};
+	},
+	unknownUrType(urType, span$1) {
+		return {
+			type: "UnknownUrType",
+			urType,
+			span: span$1
+		};
+	},
+	invalidUr(message, span$1) {
+		return {
+			type: "InvalidUr",
+			message,
+			span: span$1
+		};
+	},
+	invalidKnownValue(value, span$1) {
+		return {
+			type: "InvalidKnownValue",
+			value,
+			span: span$1
+		};
+	},
+	unknownKnownValueName(name, span$1) {
+		return {
+			type: "UnknownKnownValueName",
+			name,
+			span: span$1
+		};
+	},
+	invalidDateString(dateString, span$1) {
+		return {
+			type: "InvalidDateString",
+			dateString,
+			span: span$1
+		};
+	},
+	duplicateMapKey(span$1) {
+		return {
+			type: "DuplicateMapKey",
+			span: span$1
+		};
+	}
+};
+/**
+* Checks if an error is the default unrecognized token error.
+*
+* Corresponds to Rust `Error::is_default()`
+*/
+function isDefaultError(error) {
+	return error.type === "UnrecognizedToken";
+}
+/**
+* Gets the error message for a parse error.
+*
+* Corresponds to Rust's `Display` implementation for `Error`
+*/
+function errorMessage(error) {
+	switch (error.type) {
+		case "EmptyInput": return "Empty input";
+		case "UnexpectedEndOfInput": return "Unexpected end of input";
+		case "ExtraData": return "Extra data at end of input";
+		case "UnexpectedToken": return `Unexpected token ${tokenDebugString(error.token)}`;
+		case "UnrecognizedToken": return "Unrecognized token";
+		case "ExpectedComma": return "Expected comma";
+		case "ExpectedColon": return "Expected colon";
+		case "UnmatchedParentheses": return "Unmatched parentheses";
+		case "UnmatchedBraces": return "Unmatched braces";
+		case "ExpectedMapKey": return "Expected map key";
+		case "InvalidTagValue": return `Invalid tag value '${error.value}'`;
+		case "UnknownTagName": return `Unknown tag name '${error.name}'`;
+		case "InvalidHexString": return "Invalid hex string";
+		case "InvalidBase64String": return "Invalid base64 string";
+		case "UnknownUrType": return `Unknown UR type '${error.urType}'`;
+		case "InvalidUr": return `Invalid UR '${error.message}'`;
+		case "InvalidKnownValue": return `Invalid known value '${error.value}'`;
+		case "UnknownKnownValueName": return `Unknown known value name '${error.name}'`;
+		case "InvalidDateString": return `Invalid date string '${error.dateString}'`;
+		case "DuplicateMapKey": return "Duplicate map key";
+	}
+}
+/**
+* Gets the span for a parse error, if applicable.
+*/
+function errorSpan(error) {
+	switch (error.type) {
+		case "EmptyInput":
+		case "UnexpectedEndOfInput": return;
+		case "ExtraData":
+		case "UnexpectedToken":
+		case "UnrecognizedToken":
+		case "ExpectedComma":
+		case "ExpectedColon":
+		case "UnmatchedParentheses":
+		case "UnmatchedBraces":
+		case "ExpectedMapKey":
+		case "InvalidTagValue":
+		case "UnknownTagName":
+		case "InvalidHexString":
+		case "InvalidBase64String":
+		case "UnknownUrType":
+		case "InvalidUr":
+		case "InvalidKnownValue":
+		case "UnknownKnownValueName":
+		case "InvalidDateString":
+		case "DuplicateMapKey": return error.span;
+	}
+}
+/**
+* Formats an error message with source context, line number, and caret.
+*
+* Corresponds to Rust `Error::format_message()`
+*/
+function formatMessage(message, source, range) {
+	const start = range.start;
+	const end = range.end;
+	let lineNumber = 1;
+	let lineStart = 0;
+	for (let idx = 0; idx < source.length && idx < start; idx++) if (source[idx] === "\n") {
+		lineNumber++;
+		lineStart = idx + 1;
+	}
+	const line = source.split("\n")[lineNumber - 1] ?? "";
+	const column = Math.max(0, start - lineStart);
+	const underlineLen = Math.max(1, end - start);
+	const caret = " ".repeat(column) + "^".repeat(underlineLen);
+	return `line ${lineNumber}: ${message}\n${line}\n${caret}`;
+}
+/**
+* Gets the full error message with source context.
+*
+* Corresponds to Rust `Error::full_message()`
+*/
+function fullErrorMessage(error, source) {
+	const message = errorMessage(error);
+	switch (error.type) {
+		case "EmptyInput": return formatMessage(message, source, defaultSpan());
+		case "UnexpectedEndOfInput": return formatMessage(message, source, span(source.length, source.length));
+		case "ExtraData":
+		case "UnexpectedToken":
+		case "UnrecognizedToken":
+		case "ExpectedComma":
+		case "ExpectedColon":
+		case "UnmatchedParentheses":
+		case "UnmatchedBraces":
+		case "ExpectedMapKey":
+		case "InvalidTagValue":
+		case "UnknownTagName":
+		case "InvalidHexString":
+		case "InvalidBase64String":
+		case "UnknownUrType":
+		case "InvalidUr":
+		case "InvalidKnownValue":
+		case "UnknownKnownValueName":
+		case "InvalidDateString":
+		case "DuplicateMapKey": return formatMessage(message, source, error.span);
+	}
+}
+/**
+* Creates a default parse error (UnrecognizedToken with empty span).
+*
+* Corresponds to Rust `Error::default()`
+*/
+function defaultParseError() {
+	return parseError.unrecognizedToken(defaultSpan());
+}
+/**
+* Creates a successful result.
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+/**
+* Creates an error result.
+*/
+function err(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+/**
+* Checks if a result is successful.
+*/
+function isOk(result) {
+	return result.ok;
+}
+/**
+* Checks if a result is an error.
+*/
+function isErr(result) {
+	return !result.ok;
+}
+/**
+* Unwraps a result, throwing if it's an error.
+*/
+function unwrap(result) {
+	if (result.ok) return result.value;
+	throw new Error(errorMessage(result.error));
+}
+/**
+* Unwraps a result error, throwing if it's successful.
+*/
+function unwrapErr(result) {
+	if (!result.ok) return result.error;
+	throw new Error("Called unwrapErr on an Ok result");
+}
+function tokenDebugString(token$1) {
+	return JSON.stringify(token$1);
+}
+
+//#endregion
+//#region src/token.ts
+/**
+* @bcts/dcbor-parse - Token types and Lexer
+*
+* This is a 1:1 TypeScript port of bc-dcbor-parse-rust token.rs
+*
+* @module dcbor-parse/token
+*/
+const token = {
+	bool(value) {
+		return {
+			type: "Bool",
+			value
+		};
+	},
+	braceOpen() {
+		return { type: "BraceOpen" };
+	},
+	braceClose() {
+		return { type: "BraceClose" };
+	},
+	bracketOpen() {
+		return { type: "BracketOpen" };
+	},
+	bracketClose() {
+		return { type: "BracketClose" };
+	},
+	parenthesisOpen() {
+		return { type: "ParenthesisOpen" };
+	},
+	parenthesisClose() {
+		return { type: "ParenthesisClose" };
+	},
+	colon() {
+		return { type: "Colon" };
+	},
+	comma() {
+		return { type: "Comma" };
+	},
+	null() {
+		return { type: "Null" };
+	},
+	nan() {
+		return { type: "NaN" };
+	},
+	infinity() {
+		return { type: "Infinity" };
+	},
+	negInfinity() {
+		return { type: "NegInfinity" };
+	},
+	byteStringHex(value) {
+		return {
+			type: "ByteStringHex",
+			value
+		};
+	},
+	byteStringBase64(value) {
+		return {
+			type: "ByteStringBase64",
+			value
+		};
+	},
+	dateLiteral(value) {
+		return {
+			type: "DateLiteral",
+			value
+		};
+	},
+	number(value) {
+		return {
+			type: "Number",
+			value
+		};
+	},
+	string(value) {
+		return {
+			type: "String",
+			value
+		};
+	},
+	tagValue(value) {
+		return {
+			type: "TagValue",
+			value
+		};
+	},
+	tagName(value) {
+		return {
+			type: "TagName",
+			value
+		};
+	},
+	knownValueNumber(value) {
+		return {
+			type: "KnownValueNumber",
+			value
+		};
+	},
+	knownValueName(value) {
+		return {
+			type: "KnownValueName",
+			value
+		};
+	},
+	unit() {
+		return { type: "Unit" };
+	},
+	ur(value) {
+		return {
+			type: "UR",
+			value
+		};
+	}
+};
+/**
+* Lexer for dCBOR diagnostic notation.
+*
+* Corresponds to the Rust `logos::Lexer` used in parse.rs
+*/
+var Lexer = class {
+	#source;
+	#position;
+	#tokenStart;
+	#tokenEnd;
+	constructor(source) {
+		this.#source = source;
+		this.#position = 0;
+		this.#tokenStart = 0;
+		this.#tokenEnd = 0;
+	}
+	/**
+	* Gets the current span (position range of the last token).
+	*/
+	span() {
+		return span(this.#tokenStart, this.#tokenEnd);
+	}
+	/**
+	* Gets the slice of source corresponding to the last token.
+	*/
+	slice() {
+		return this.#source.slice(this.#tokenStart, this.#tokenEnd);
+	}
+	/**
+	* Gets the next token, or undefined if at end of input.
+	* Returns a Result to handle lexing errors.
+	*/
+	next() {
+		this.#skipWhitespaceAndComments();
+		if (this.#position >= this.#source.length) return;
+		this.#tokenStart = this.#position;
+		const result = this.#tryMatchKeyword() ?? this.#tryMatchDateLiteral() ?? this.#tryMatchTagValueOrNumber() ?? this.#tryMatchTagName() ?? this.#tryMatchString() ?? this.#tryMatchByteStringHex() ?? this.#tryMatchByteStringBase64() ?? this.#tryMatchKnownValue() ?? this.#tryMatchUR() ?? this.#tryMatchPunctuation();
+		if (result === void 0) {
+			this.#position++;
+			this.#tokenEnd = this.#position;
+			return err(parseError.unrecognizedToken(this.span()));
+		}
+		return result;
+	}
+	#skipWhitespaceAndComments() {
+		while (this.#position < this.#source.length) {
+			const ch = this.#source[this.#position];
+			if (ch === " " || ch === "	" || ch === "\r" || ch === "\n" || ch === "\f") {
+				this.#position++;
+				continue;
+			}
+			if (ch === "/" && this.#position + 1 < this.#source.length && this.#source[this.#position + 1] !== "/") {
+				this.#position++;
+				while (this.#position < this.#source.length && this.#source[this.#position] !== "/") this.#position++;
+				if (this.#position < this.#source.length) this.#position++;
+				continue;
+			}
+			if (ch === "#") {
+				while (this.#position < this.#source.length && this.#source[this.#position] !== "\n") this.#position++;
+				continue;
+			}
+			break;
+		}
+	}
+	#tryMatchKeyword() {
+		const keywords = [
+			["true", token.bool(true)],
+			["false", token.bool(false)],
+			["null", token.null()],
+			["NaN", token.nan()],
+			["Infinity", token.infinity()],
+			["-Infinity", token.negInfinity()],
+			["Unit", token.unit()]
+		];
+		for (const [keyword, tok] of keywords) if (this.#matchLiteral(keyword)) {
+			const nextChar = this.#source[this.#position];
+			if (nextChar === void 0 || !this.#isIdentifierChar(nextChar)) {
+				this.#tokenEnd = this.#position;
+				return ok(tok);
+			}
+			this.#position = this.#tokenStart;
+		}
+	}
+	#tryMatchDateLiteral() {
+		const dateRegex = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?/;
+		const remaining = this.#source.slice(this.#position);
+		const match = dateRegex.exec(remaining);
+		if (match !== null) {
+			const dateStr = match[0];
+			this.#position += dateStr.length;
+			this.#tokenEnd = this.#position;
+			if (!isValidDateString(dateStr)) return err(parseError.invalidDateString(dateStr, this.span()));
+			try {
+				const date = CborDate.fromString(dateStr);
+				return ok(token.dateLiteral(date));
+			} catch {
+				return err(parseError.invalidDateString(dateStr, this.span()));
+			}
+		}
+	}
+	#tryMatchTagValueOrNumber() {
+		const numberRegex = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/;
+		const remaining = this.#source.slice(this.#position);
+		const match = numberRegex.exec(remaining);
+		if (match !== null) {
+			const numStr = match[0];
+			if (this.#source[this.#position + numStr.length] === "(" && !numStr.includes(".") && !numStr.includes("e") && !numStr.includes("E") && !numStr.startsWith("-")) {
+				this.#position += numStr.length + 1;
+				this.#tokenEnd = this.#position;
+				const tagValue = parseInt(numStr, 10);
+				if (!Number.isSafeInteger(tagValue) || tagValue < 0) return err(parseError.invalidTagValue(numStr, span(this.#tokenStart, this.#tokenStart + numStr.length)));
+				return ok(token.tagValue(tagValue));
+			}
+			this.#position += numStr.length;
+			this.#tokenEnd = this.#position;
+			const num = parseFloat(numStr);
+			return ok(token.number(num));
+		}
+	}
+	#tryMatchTagName() {
+		const tagNameRegex = /^[a-zA-Z_][a-zA-Z0-9_-]*\(/;
+		const remaining = this.#source.slice(this.#position);
+		const match = tagNameRegex.exec(remaining);
+		if (match !== null) {
+			const fullMatch = match[0];
+			const name = fullMatch.slice(0, -1);
+			this.#position += fullMatch.length;
+			this.#tokenEnd = this.#position;
+			return ok(token.tagName(name));
+		}
+	}
+	#tryMatchString() {
+		if (this.#source[this.#position] !== "\"") return;
+		const stringRegex = /^"([^"\\\x00-\x1F]|\\(["\\bnfrt/]|u[a-fA-F0-9]{4}))*"/;
+		const remaining = this.#source.slice(this.#position);
+		const match = stringRegex.exec(remaining);
+		if (match !== null) {
+			const fullMatch = match[0];
+			this.#position += fullMatch.length;
+			this.#tokenEnd = this.#position;
+			return ok(token.string(fullMatch));
+		}
+		this.#position++;
+		while (this.#position < this.#source.length) {
+			const ch = this.#source[this.#position];
+			if (ch === "\"" || ch === "\n") {
+				if (ch === "\"") this.#position++;
+				break;
+			}
+			if (ch === "\\") this.#position += 2;
+			else this.#position++;
+		}
+		this.#tokenEnd = this.#position;
+		return err(parseError.unrecognizedToken(this.span()));
+	}
+	#tryMatchByteStringHex() {
+		if (!this.#matchLiteral("h'")) return;
+		const hexRegex = /^[0-9a-fA-F]*/;
+		const remaining = this.#source.slice(this.#position);
+		const match = hexRegex.exec(remaining);
+		const hexPart = match !== null ? match[0] : "";
+		this.#position += hexPart.length;
+		if (this.#source[this.#position] !== "'") {
+			this.#tokenEnd = this.#position;
+			return err(parseError.invalidHexString(this.span()));
+		}
+		this.#position++;
+		this.#tokenEnd = this.#position;
+		if (hexPart.length % 2 !== 0) return err(parseError.invalidHexString(this.span()));
+		const bytes = hexToBytes(hexPart);
+		return ok(token.byteStringHex(bytes));
+	}
+	#tryMatchByteStringBase64() {
+		if (!this.#matchLiteral("b64'")) return;
+		const base64Regex = /^[A-Za-z0-9+/=]*/;
+		const remaining = this.#source.slice(this.#position);
+		const match = base64Regex.exec(remaining);
+		const base64Part = match !== null ? match[0] : "";
+		this.#position += base64Part.length;
+		if (this.#source[this.#position] !== "'") {
+			this.#tokenEnd = this.#position;
+			return err(parseError.invalidBase64String(this.span()));
+		}
+		this.#position++;
+		this.#tokenEnd = this.#position;
+		if (base64Part.length < 2) return err(parseError.invalidBase64String(this.span()));
+		try {
+			const bytes = base64ToBytes(base64Part);
+			return ok(token.byteStringBase64(bytes));
+		} catch {
+			return err(parseError.invalidBase64String(this.span()));
+		}
+	}
+	#tryMatchKnownValue() {
+		if (this.#source[this.#position] !== "'") return;
+		if (this.#source[this.#position + 1] === "'") {
+			this.#position += 2;
+			this.#tokenEnd = this.#position;
+			return ok(token.knownValueName(""));
+		}
+		const numericRegex = /^'(0|[1-9][0-9]*)'/;
+		const remaining = this.#source.slice(this.#position);
+		let match = numericRegex.exec(remaining);
+		if (match !== null) {
+			const fullMatch = match[0];
+			const numStr = match[1];
+			this.#position += fullMatch.length;
+			this.#tokenEnd = this.#position;
+			const value = parseInt(numStr, 10);
+			if (!Number.isSafeInteger(value) || value < 0) return err(parseError.invalidKnownValue(numStr, span(this.#tokenStart + 1, this.#tokenEnd - 1)));
+			return ok(token.knownValueNumber(value));
+		}
+		match = /^'([a-zA-Z_][a-zA-Z0-9_-]*)'/.exec(remaining);
+		if (match !== null) {
+			const fullMatch = match[0];
+			const name = match[1];
+			this.#position += fullMatch.length;
+			this.#tokenEnd = this.#position;
+			return ok(token.knownValueName(name));
+		}
+		this.#position++;
+		while (this.#position < this.#source.length && this.#source[this.#position] !== "'") this.#position++;
+		if (this.#position < this.#source.length) this.#position++;
+		this.#tokenEnd = this.#position;
+		return err(parseError.unrecognizedToken(this.span()));
+	}
+	#tryMatchUR() {
+		const urRegex = /^ur:([a-zA-Z0-9][a-zA-Z0-9-]*)\/([a-zA-Z]{8,})/;
+		const remaining = this.#source.slice(this.#position);
+		const match = urRegex.exec(remaining);
+		if (match !== null) {
+			const fullMatch = match[0];
+			this.#position += fullMatch.length;
+			this.#tokenEnd = this.#position;
+			try {
+				const ur = UR.fromURString(fullMatch);
+				return ok(token.ur(ur));
+			} catch (e) {
+				const errorMsg = e instanceof Error ? e.message : String(e);
+				return err(parseError.invalidUr(errorMsg, this.span()));
+			}
+		}
+	}
+	#tryMatchPunctuation() {
+		const ch = this.#source[this.#position];
+		const matched = {
+			"{": token.braceOpen(),
+			"}": token.braceClose(),
+			"[": token.bracketOpen(),
+			"]": token.bracketClose(),
+			"(": token.parenthesisOpen(),
+			")": token.parenthesisClose(),
+			":": token.colon(),
+			",": token.comma()
+		}[ch];
+		if (matched !== void 0) {
+			this.#position++;
+			this.#tokenEnd = this.#position;
+			return ok(matched);
+		}
+	}
+	#matchLiteral(literal) {
+		if (this.#source.slice(this.#position, this.#position + literal.length) === literal) {
+			this.#position += literal.length;
+			return true;
+		}
+		return false;
+	}
+	#isIdentifierChar(ch) {
+		return /[a-zA-Z0-9_-]/.test(ch);
+	}
+};
+/**
+* Converts a hex string to bytes.
+*/
+function hexToBytes(hex) {
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return bytes;
+}
+/**
+* Converts a base64 string to bytes with strict validation.
+* Rejects base64 strings with invalid padding (matches Rust's base64 crate behavior).
+*/
+function base64ToBytes(base64) {
+	const expectedPadding = (4 - base64.replace(/=/g, "").length % 4) % 4;
+	const paddingMatch = /=+$/.exec(base64);
+	if (expectedPadding !== (paddingMatch !== null ? paddingMatch[0].length : 0)) throw new Error("Invalid base64 padding");
+	const binaryString = atob(base64);
+	const bytes = new Uint8Array(binaryString.length);
+	for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+	return bytes;
+}
+/**
+* Validates a date string has valid month/day values.
+* JavaScript Date is lenient and accepts invalid dates like 2023-02-30,
+* but Rust's Date::from_string rejects them.
+*/
+function isValidDateString(dateStr) {
+	const dateMatch = /^(\d{4})-(\d{2})-(\d{2})/.exec(dateStr);
+	if (dateMatch === null) return false;
+	const year = parseInt(dateMatch[1], 10);
+	const month = parseInt(dateMatch[2], 10);
+	const day = parseInt(dateMatch[3], 10);
+	if (month < 1 || month > 12) return false;
+	if (day < 1) return false;
+	const daysInMonth = [
+		31,
+		28,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	];
+	if ((year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) && month === 2) {
+		if (day > 29) return false;
+	} else if (day > daysInMonth[month - 1]) return false;
+	const timeMatch = /T(\d{2}):(\d{2}):(\d{2})/.exec(dateStr);
+	if (timeMatch !== null) {
+		const hour = parseInt(timeMatch[1], 10);
+		const minute = parseInt(timeMatch[2], 10);
+		const second = parseInt(timeMatch[3], 10);
+		if (hour < 0 || hour > 23) return false;
+		if (minute < 0 || minute > 59) return false;
+		if (second < 0 || second > 59) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/parse.ts
+/**
+* @bcts/dcbor-parse - Parse module
+*
+* This is a 1:1 TypeScript port of bc-dcbor-parse-rust parse.rs
+*
+* @module dcbor-parse/parse
+*/
+/**
+* Parses a dCBOR item from a string input.
+*
+* This function takes a string slice containing a dCBOR diagnostic notation
+* encoded value and attempts to parse it into a `Cbor` object. If the input
+* contains extra tokens after a valid item, an error is returned.
+*
+* @param src - A string containing the dCBOR-encoded data.
+* @returns `Ok(Cbor)` if parsing is successful and the input contains exactly one
+*   valid dCBOR item, which itself might be an atomic value like a number or
+*   string, or a complex value like an array or map.
+*   `Err(ParseError)` if parsing fails or if extra tokens are found after the item.
+*
+* @example
+* ```typescript
+* const result = parseDcborItem("[1, 2, 3]");
+* if (result.ok) {
+*   console.log(result.value.toDiagnostic()); // "[1, 2, 3]"
+* }
+* ```
+*/
+function parseDcborItem(src) {
+	const lexer = new Lexer(src);
+	const firstTokenResult = expectToken(lexer);
+	if (!firstTokenResult.ok) {
+		if (firstTokenResult.error.type === "UnexpectedEndOfInput") return err(parseError.emptyInput());
+		return firstTokenResult;
+	}
+	const parseResult = parseItemToken(firstTokenResult.value, lexer);
+	if (!parseResult.ok) return parseResult;
+	if (lexer.next() !== void 0) return err(parseError.extraData(lexer.span()));
+	return parseResult;
+}
+/**
+* Parses a dCBOR item from the beginning of a string and returns the parsed
+* `Cbor` along with the number of bytes consumed.
+*
+* Unlike `parseDcborItem`, this function succeeds even if additional
+* characters follow the first item. The returned index points to the first
+* unparsed character after skipping any trailing whitespace or comments.
+*
+* @param src - A string containing the dCBOR-encoded data.
+* @returns `Ok([Cbor, number])` with the parsed item and bytes consumed.
+*
+* @example
+* ```typescript
+* const result = parseDcborItemPartial("true )");
+* if (result.ok) {
+*   const [cbor, used] = result.value;
+*   console.log(cbor.toDiagnostic()); // "true"
+*   console.log(used); // 5
+* }
+* ```
+*/
+function parseDcborItemPartial(src) {
+	const lexer = new Lexer(src);
+	const firstTokenResult = expectToken(lexer);
+	if (!firstTokenResult.ok) {
+		if (firstTokenResult.error.type === "UnexpectedEndOfInput") return err(parseError.emptyInput());
+		return firstTokenResult;
+	}
+	const parseResult = parseItemToken(firstTokenResult.value, lexer);
+	if (!parseResult.ok) return parseResult;
+	const consumed = lexer.next() !== void 0 ? lexer.span().start : src.length;
+	return ok([parseResult.value, consumed]);
+}
+function parseItem(lexer) {
+	const tokenResult = expectToken(lexer);
+	if (!tokenResult.ok) return tokenResult;
+	return parseItemToken(tokenResult.value, lexer);
+}
+function expectToken(lexer) {
+	const spanBefore = lexer.span();
+	const result = lexer.next();
+	if (result === void 0) return err(parseError.unexpectedEndOfInput());
+	if (!result.ok) {
+		if (isDefaultError(result.error)) return err(parseError.unrecognizedToken(spanBefore));
+		return result;
+	}
+	return result;
+}
+function parseItemToken(token$1, lexer) {
+	switch (token$1.type) {
+		case "Bool": return ok(cbor(token$1.value));
+		case "Null": return ok(cbor(null));
+		case "ByteStringHex": return ok(cbor(token$1.value));
+		case "ByteStringBase64": return ok(cbor(token$1.value));
+		case "DateLiteral": return ok(cbor(token$1.value));
+		case "Number": return ok(cbor(token$1.value));
+		case "NaN": return ok(cbor(NaN));
+		case "Infinity": return ok(cbor(Number.POSITIVE_INFINITY));
+		case "NegInfinity": return ok(cbor(Number.NEGATIVE_INFINITY));
+		case "String": return parseString(token$1.value, lexer.span());
+		case "UR": return parseUr(token$1.value, lexer.span());
+		case "TagValue": return parseNumberTag(token$1.value, lexer);
+		case "TagName": return parseNameTag(token$1.value, lexer);
+		case "KnownValueNumber": return ok(new KnownValue(token$1.value).taggedCbor());
+		case "KnownValueName": {
+			if (token$1.value === "") return ok(new KnownValue(0).taggedCbor());
+			const knownValue = knownValueForName(token$1.value);
+			if (knownValue !== void 0) return ok(knownValue.taggedCbor());
+			const tokenSpan = lexer.span();
+			return err(parseError.unknownKnownValueName(token$1.value, span(tokenSpan.start + 1, tokenSpan.end - 1)));
+		}
+		case "Unit": return ok(new KnownValue(0).taggedCbor());
+		case "BracketOpen": return parseArray(lexer);
+		case "BraceOpen": return parseMap(lexer);
+		case "BraceClose":
+		case "BracketClose":
+		case "ParenthesisOpen":
+		case "ParenthesisClose":
+		case "Colon":
+		case "Comma": return err(parseError.unexpectedToken(token$1, lexer.span()));
+	}
+}
+function parseString(s, tokenSpan) {
+	if (s.startsWith("\"") && s.endsWith("\"")) return ok(cbor(s.slice(1, -1)));
+	return err(parseError.unrecognizedToken(tokenSpan));
+}
+function tagForName(name) {
+	return getGlobalTagsStore().tagForName(name)?.value;
+}
+function knownValueForName(name) {
+	return KNOWN_VALUES.get().knownValueNamed(name);
+}
+function parseUr(ur, tokenSpan) {
+	const urType = ur.urTypeStr();
+	const tag = tagForName(urType);
+	if (tag !== void 0) return ok(cbor({
+		tag,
+		value: ur.cbor()
+	}));
+	return err(parseError.unknownUrType(urType, span(tokenSpan.start + 3, tokenSpan.start + 3 + urType.length)));
+}
+function parseNumberTag(tagValue, lexer) {
+	const itemResult = parseItem(lexer);
+	if (!itemResult.ok) return itemResult;
+	const closeResult = expectToken(lexer);
+	if (!closeResult.ok) {
+		if (closeResult.error.type === "UnexpectedEndOfInput") return err(parseError.unmatchedParentheses(lexer.span()));
+		return closeResult;
+	}
+	if (closeResult.value.type === "ParenthesisClose") return ok(cbor({
+		tag: tagValue,
+		value: itemResult.value
+	}));
+	return err(parseError.unmatchedParentheses(lexer.span()));
+}
+function parseNameTag(name, lexer) {
+	const tagSpan = span(lexer.span().start, lexer.span().end - 1);
+	const itemResult = parseItem(lexer);
+	if (!itemResult.ok) return itemResult;
+	const closeResult = expectToken(lexer);
+	if (!closeResult.ok) return closeResult;
+	if (closeResult.value.type === "ParenthesisClose") {
+		const tag = tagForName(name);
+		if (tag !== void 0) return ok(cbor({
+			tag,
+			value: itemResult.value
+		}));
+		return err(parseError.unknownTagName(name, tagSpan));
+	}
+	return err(parseError.unmatchedParentheses(lexer.span()));
+}
+function parseArray(lexer) {
+	const items = [];
+	let awaitsComma = false;
+	let awaitsItem = false;
+	while (true) {
+		const tokenResult = expectToken(lexer);
+		if (!tokenResult.ok) return tokenResult;
+		const token$1 = tokenResult.value;
+		if (token$1.type === "BracketClose" && !awaitsItem) return ok(cbor(items));
+		if (token$1.type === "Comma" && awaitsComma) {
+			awaitsItem = true;
+			awaitsComma = false;
+			continue;
+		}
+		if (awaitsComma) return err(parseError.expectedComma(lexer.span()));
+		const itemResult = parseItemToken(token$1, lexer);
+		if (!itemResult.ok) return itemResult;
+		items.push(itemResult.value);
+		awaitsItem = false;
+		awaitsComma = true;
+	}
+}
+function parseMap(lexer) {
+	const map = new CborMap();
+	let awaitsComma = false;
+	let awaitsKey = false;
+	while (true) {
+		const tokenResult = expectToken(lexer);
+		if (!tokenResult.ok) {
+			if (tokenResult.error.type === "UnexpectedEndOfInput") return err(parseError.unmatchedBraces(lexer.span()));
+			return tokenResult;
+		}
+		const token$1 = tokenResult.value;
+		if (token$1.type === "BraceClose" && !awaitsKey) return ok(cbor(map));
+		if (token$1.type === "Comma" && awaitsComma) {
+			awaitsKey = true;
+			awaitsComma = false;
+			continue;
+		}
+		if (awaitsComma) return err(parseError.expectedComma(lexer.span()));
+		const keyResult = parseItemToken(token$1, lexer);
+		if (!keyResult.ok) return keyResult;
+		const key = keyResult.value;
+		const keySpan = lexer.span();
+		if (map.has(key)) return err(parseError.duplicateMapKey(keySpan));
+		const colonResult = expectToken(lexer);
+		if (!colonResult.ok) return colonResult;
+		if (colonResult.value.type !== "Colon") return err(parseError.expectedColon(lexer.span()));
+		const valueResult = parseItem(lexer);
+		if (!valueResult.ok) {
+			if (valueResult.error.type === "UnexpectedToken") {
+				if (valueResult.error.token.type === "BraceClose") return err(parseError.expectedMapKey(lexer.span()));
+			}
+			return valueResult;
+		}
+		map.set(key, valueResult.value);
+		awaitsKey = false;
+		awaitsComma = true;
+	}
+}
+
+//#endregion
+//#region src/compose.ts
+/**
+* @bcts/dcbor-parse - Compose module
+*
+* This is a 1:1 TypeScript port of bc-dcbor-parse-rust compose.rs
+*
+* @module dcbor-parse/compose
+*/
+const composeError = {
+	oddMapLength() {
+		return { type: "OddMapLength" };
+	},
+	duplicateMapKey() {
+		return { type: "DuplicateMapKey" };
+	},
+	parseError(error) {
+		return {
+			type: "ParseError",
+			error
+		};
+	}
+};
+/**
+* Gets the error message for a compose error.
+*/
+function composeErrorMessage(error) {
+	switch (error.type) {
+		case "OddMapLength": return "Invalid odd map length";
+		case "DuplicateMapKey": return "Duplicate map key";
+		case "ParseError": return `Invalid CBOR item: ${error.error.type}`;
+	}
+}
+/**
+* Creates a successful compose result.
+*/
+function composeOk(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+/**
+* Creates an error compose result.
+*/
+function composeErr(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+/**
+* Composes a dCBOR array from a slice of string slices, and returns a CBOR
+* object representing the array.
+*
+* Each string slice is parsed as a dCBOR item.
+*
+* @param array - Array of strings, each representing a dCBOR item
+* @returns A CBOR array containing all parsed items
+*
+* @example
+* ```typescript
+* const result = composeDcborArray(["1", "2", "3"]);
+* if (result.ok) {
+*   console.log(result.value.toDiagnostic()); // "[1, 2, 3]"
+* }
+* ```
+*/
+function composeDcborArray(array) {
+	const result = [];
+	for (const item of array) {
+		const parseResult = parseDcborItem(item);
+		if (!parseResult.ok) return composeErr(composeError.parseError(parseResult.error));
+		result.push(parseResult.value);
+	}
+	return composeOk(cbor(result));
+}
+/**
+* Composes a dCBOR map from a slice of string slices, and returns a CBOR
+* object representing the map.
+*
+* The length of the slice must be even, as each key must have a corresponding
+* value.
+*
+* Each string slice is parsed as a dCBOR item.
+*
+* @param array - Array of strings representing key-value pairs in alternating order
+* @returns A CBOR map containing all parsed key-value pairs
+*
+* @example
+* ```typescript
+* const result = composeDcborMap(["1", "2", "3", "4"]);
+* if (result.ok) {
+*   console.log(result.value.toDiagnostic()); // "{1: 2, 3: 4}"
+* }
+* ```
+*/
+function composeDcborMap(array) {
+	if (array.length % 2 !== 0) return composeErr(composeError.oddMapLength());
+	const map = new CborMap();
+	for (let i = 0; i < array.length; i += 2) {
+		const keyStr = array[i];
+		const valueStr = array[i + 1];
+		const keyResult = parseDcborItem(keyStr);
+		if (!keyResult.ok) return composeErr(composeError.parseError(keyResult.error));
+		const valueResult = parseDcborItem(valueStr);
+		if (!valueResult.ok) return composeErr(composeError.parseError(valueResult.error));
+		if (map.has(keyResult.value)) return composeErr(composeError.duplicateMapKey());
+		map.set(keyResult.value, valueResult.value);
+	}
+	return composeOk(cbor(map));
+}
+
+//#endregion
+export { Lexer, composeDcborArray, composeDcborMap, composeErr, composeError, composeErrorMessage, composeOk, defaultParseError, defaultSpan, err, errorMessage, errorSpan, fullErrorMessage, isDefaultError, isErr, isOk, ok, parseDcborItem, parseDcborItemPartial, parseError, span, token, unwrap, unwrapErr };
+//# sourceMappingURL=index.mjs.map