@bcts/dcbor-parse 1.0.0-alpha.13

package/dist/index.iife.js

@@ -0,0 +1,1142 @@
+var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _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 = _bcts_dcbor.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 = _bcts_uniform_resources.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((0, _bcts_dcbor.cbor)(token$1.value));
+			case "Null": return ok((0, _bcts_dcbor.cbor)(null));
+			case "ByteStringHex": return ok((0, _bcts_dcbor.cbor)(token$1.value));
+			case "ByteStringBase64": return ok((0, _bcts_dcbor.cbor)(token$1.value));
+			case "DateLiteral": return ok((0, _bcts_dcbor.cbor)(token$1.value));
+			case "Number": return ok((0, _bcts_dcbor.cbor)(token$1.value));
+			case "NaN": return ok((0, _bcts_dcbor.cbor)(NaN));
+			case "Infinity": return ok((0, _bcts_dcbor.cbor)(Number.POSITIVE_INFINITY));
+			case "NegInfinity": return ok((0, _bcts_dcbor.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 _bcts_known_values.KnownValue(token$1.value).taggedCbor());
+			case "KnownValueName": {
+				if (token$1.value === "") return ok(new _bcts_known_values.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 _bcts_known_values.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((0, _bcts_dcbor.cbor)(s.slice(1, -1)));
+		return err(parseError.unrecognizedToken(tokenSpan));
+	}
+	function tagForName(name) {
+		return (0, _bcts_dcbor.getGlobalTagsStore)().tagForName(name)?.value;
+	}
+	function knownValueForName(name) {
+		return _bcts_known_values.KNOWN_VALUES.get().knownValueNamed(name);
+	}
+	function parseUr(ur, tokenSpan) {
+		const urType = ur.urTypeStr();
+		const tag = tagForName(urType);
+		if (tag !== void 0) return ok((0, _bcts_dcbor.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((0, _bcts_dcbor.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((0, _bcts_dcbor.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((0, _bcts_dcbor.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 _bcts_dcbor.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((0, _bcts_dcbor.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((0, _bcts_dcbor.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 _bcts_dcbor.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((0, _bcts_dcbor.cbor)(map));
+	}
+
+//#endregion
+exports.Lexer = Lexer;
+exports.composeDcborArray = composeDcborArray;
+exports.composeDcborMap = composeDcborMap;
+exports.composeErr = composeErr;
+exports.composeError = composeError;
+exports.composeErrorMessage = composeErrorMessage;
+exports.composeOk = composeOk;
+exports.defaultParseError = defaultParseError;
+exports.defaultSpan = defaultSpan;
+exports.err = err;
+exports.errorMessage = errorMessage;
+exports.errorSpan = errorSpan;
+exports.fullErrorMessage = fullErrorMessage;
+exports.isDefaultError = isDefaultError;
+exports.isErr = isErr;
+exports.isOk = isOk;
+exports.ok = ok;
+exports.parseDcborItem = parseDcborItem;
+exports.parseDcborItemPartial = parseDcborItemPartial;
+exports.parseError = parseError;
+exports.span = span;
+exports.token = token;
+exports.unwrap = unwrap;
+exports.unwrapErr = unwrapErr;
+return exports;
+})({}, bctsDcbor, bctsKnownValues, bctsUniformResources);
+//# sourceMappingURL=index.iife.js.map