@bcts/dcbor-parse 1.0.0-alpha.16 → 1.0.0-alpha.17

package/dist/index.mjs

@@ -28,120 +28,120 @@ const parseError = {
 	unexpectedEndOfInput() {
 		return { type: "UnexpectedEndOfInput" };
 	},
-	extraData(span$1) {
+	extraData(span) {
 		return {
 			type: "ExtraData",
-			span: span$1
+			span
 		};
 	},
-	unexpectedToken(token$1, span$1) {
+	unexpectedToken(token, span) {
 		return {
 			type: "UnexpectedToken",
-			token: token$1,
-			span: span$1
+			token,
+			span
 		};
 	},
-	unrecognizedToken(span$1) {
+	unrecognizedToken(span) {
 		return {
 			type: "UnrecognizedToken",
-			span: span$1
+			span
 		};
 	},
-	expectedComma(span$1) {
+	expectedComma(span) {
 		return {
 			type: "ExpectedComma",
-			span: span$1
+			span
 		};
 	},
-	expectedColon(span$1) {
+	expectedColon(span) {
 		return {
 			type: "ExpectedColon",
-			span: span$1
+			span
 		};
 	},
-	unmatchedParentheses(span$1) {
+	unmatchedParentheses(span) {
 		return {
 			type: "UnmatchedParentheses",
-			span: span$1
+			span
 		};
 	},
-	unmatchedBraces(span$1) {
+	unmatchedBraces(span) {
 		return {
 			type: "UnmatchedBraces",
-			span: span$1
+			span
 		};
 	},
-	expectedMapKey(span$1) {
+	expectedMapKey(span) {
 		return {
 			type: "ExpectedMapKey",
-			span: span$1
+			span
 		};
 	},
-	invalidTagValue(value, span$1) {
+	invalidTagValue(value, span) {
 		return {
 			type: "InvalidTagValue",
 			value,
-			span: span$1
+			span
 		};
 	},
-	unknownTagName(name, span$1) {
+	unknownTagName(name, span) {
 		return {
 			type: "UnknownTagName",
 			name,
-			span: span$1
+			span
 		};
 	},
-	invalidHexString(span$1) {
+	invalidHexString(span) {
 		return {
 			type: "InvalidHexString",
-			span: span$1
+			span
 		};
 	},
-	invalidBase64String(span$1) {
+	invalidBase64String(span) {
 		return {
 			type: "InvalidBase64String",
-			span: span$1
+			span
 		};
 	},
-	unknownUrType(urType, span$1) {
+	unknownUrType(urType, span) {
 		return {
 			type: "UnknownUrType",
 			urType,
-			span: span$1
+			span
 		};
 	},
-	invalidUr(message, span$1) {
+	invalidUr(message, span) {
 		return {
 			type: "InvalidUr",
 			message,
-			span: span$1
+			span
 		};
 	},
-	invalidKnownValue(value, span$1) {
+	invalidKnownValue(value, span) {
 		return {
 			type: "InvalidKnownValue",
 			value,
-			span: span$1
+			span
 		};
 	},
-	unknownKnownValueName(name, span$1) {
+	unknownKnownValueName(name, span) {
 		return {
 			type: "UnknownKnownValueName",
 			name,
-			span: span$1
+			span
 		};
 	},
-	invalidDateString(dateString, span$1) {
+	invalidDateString(dateString, span) {
 		return {
 			type: "InvalidDateString",
 			dateString,
-			span: span$1
+			span
 		};
 	},
-	duplicateMapKey(span$1) {
+	duplicateMapKey(span) {
 		return {
 			type: "DuplicateMapKey",
-			span: span$1
+			span
 		};
 	}
 };
@@ -311,8 +311,8 @@ 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);
+function tokenDebugString(token) {
+	return JSON.stringify(token);
 }
 
 //#endregion
@@ -437,65 +437,65 @@ const token = {
 * Corresponds to the Rust `logos::Lexer` used in parse.rs
 */
 var Lexer = class {
-	#source;
-	#position;
-	#tokenStart;
-	#tokenEnd;
+	_source;
+	_position;
+	_tokenStart;
+	_tokenEnd;
 	constructor(source) {
-		this.#source = source;
-		this.#position = 0;
-		this.#tokenStart = 0;
-		this.#tokenEnd = 0;
+		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);
+		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);
+		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();
+		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;
+			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];
+	_skipWhitespaceAndComments() {
+		while (this._position < this._source.length) {
+			const ch = this._source[this._position];
 			if (ch === " " || ch === "	" || ch === "\r" || ch === "\n" || ch === "\f") {
-				this.#position++;
+				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++;
+			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++;
+				while (this._position < this._source.length && this._source[this._position] !== "\n") this._position++;
 				continue;
 			}
 			break;
 		}
 	}
-	#tryMatchKeyword() {
+	_tryMatchKeyword() {
 		const keywords = [
 			["true", token.bool(true)],
 			["false", token.bool(false)],
@@ -505,23 +505,23 @@ var Lexer = class {
 			["-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;
+		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;
+			this._position = this._tokenStart;
 		}
 	}
-	#tryMatchDateLiteral() {
+	_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 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;
+			this._position += dateStr.length;
+			this._tokenEnd = this._position;
 			if (!isValidDateString(dateStr)) return err(parseError.invalidDateString(dateStr, this.span()));
 			try {
 				const date = CborDate.fromString(dateStr);
@@ -531,91 +531,91 @@ var Lexer = class {
 			}
 		}
 	}
-	#tryMatchTagValueOrNumber() {
+	_tryMatchTagValueOrNumber() {
 		const numberRegex = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/;
-		const remaining = this.#source.slice(this.#position);
+		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;
+			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)));
+				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;
+			this._position += numStr.length;
+			this._tokenEnd = this._position;
 			const num = parseFloat(numStr);
 			return ok(token.number(num));
 		}
 	}
-	#tryMatchTagName() {
+	_tryMatchTagName() {
 		const tagNameRegex = /^[a-zA-Z_][a-zA-Z0-9_-]*\(/;
-		const remaining = this.#source.slice(this.#position);
+		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;
+			this._position += fullMatch.length;
+			this._tokenEnd = this._position;
 			return ok(token.tagName(name));
 		}
 	}
-	#tryMatchString() {
-		if (this.#source[this.#position] !== "\"") return;
+	_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 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;
+			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];
+		this._position++;
+		while (this._position < this._source.length) {
+			const ch = this._source[this._position];
 			if (ch === "\"" || ch === "\n") {
-				if (ch === "\"") this.#position++;
+				if (ch === "\"") this._position++;
 				break;
 			}
-			if (ch === "\\") this.#position += 2;
-			else this.#position++;
+			if (ch === "\\") this._position += 2;
+			else this._position++;
 		}
-		this.#tokenEnd = this.#position;
+		this._tokenEnd = this._position;
 		return err(parseError.unrecognizedToken(this.span()));
 	}
-	#tryMatchByteStringHex() {
-		if (!this.#matchLiteral("h'")) return;
+	_tryMatchByteStringHex() {
+		if (!this._matchLiteral("h'")) return;
 		const hexRegex = /^[0-9a-fA-F]*/;
-		const remaining = this.#source.slice(this.#position);
+		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;
+		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;
+		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;
+	_tryMatchByteStringBase64() {
+		if (!this._matchLiteral("b64'")) return;
 		const base64Regex = /^[A-Za-z0-9+/=]*/;
-		const remaining = this.#source.slice(this.#position);
+		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;
+		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;
+		this._position++;
+		this._tokenEnd = this._position;
 		if (base64Part.length < 2) return err(parseError.invalidBase64String(this.span()));
 		try {
 			const bytes = base64ToBytes(base64Part);
@@ -624,47 +624,47 @@ var Lexer = class {
 			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;
+	_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);
+		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;
+			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)));
+			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;
+			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;
+		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() {
+	_tryMatchUR() {
 		const urRegex = /^ur:([a-zA-Z0-9][a-zA-Z0-9-]*)\/([a-zA-Z]{8,})/;
-		const remaining = this.#source.slice(this.#position);
+		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;
+			this._position += fullMatch.length;
+			this._tokenEnd = this._position;
 			try {
 				const ur = UR.fromURString(fullMatch);
 				return ok(token.ur(ur));
@@ -674,8 +674,8 @@ var Lexer = class {
 			}
 		}
 	}
-	#tryMatchPunctuation() {
-		const ch = this.#source[this.#position];
+	_tryMatchPunctuation() {
+		const ch = this._source[this._position];
 		const matched = {
 			"{": token.braceOpen(),
 			"}": token.braceClose(),
@@ -687,19 +687,19 @@ var Lexer = class {
 			",": token.comma()
 		}[ch];
 		if (matched !== void 0) {
-			this.#position++;
-			this.#tokenEnd = this.#position;
+			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;
+	_matchLiteral(literal) {
+		if (this._source.slice(this._position, this._position + literal.length) === literal) {
+			this._position += literal.length;
 			return true;
 		}
 		return false;
 	}
-	#isIdentifierChar(ch) {
+	_isIdentifierChar(ch) {
 		return /[a-zA-Z0-9_-]/.test(ch);
 	}
 };
@@ -856,28 +856,28 @@ function expectToken(lexer) {
 	}
 	return result;
 }
-function parseItemToken(token$1, lexer) {
-	switch (token$1.type) {
-		case "Bool": return ok(cbor(token$1.value));
+function parseItemToken(token, lexer) {
+	switch (token.type) {
+		case "Bool": return ok(cbor(token.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 "ByteStringHex": return ok(cbor(token.value));
+		case "ByteStringBase64": return ok(cbor(token.value));
+		case "DateLiteral": return ok(cbor(token.value));
+		case "Number": return ok(cbor(token.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 "String": return parseString(token.value, lexer.span());
+		case "UR": return parseUr(token.value, lexer.span());
+		case "TagValue": return parseNumberTag(token.value, lexer);
+		case "TagName": return parseNameTag(token.value, lexer);
+		case "KnownValueNumber": return ok(new KnownValue(token.value).taggedCbor());
 		case "KnownValueName": {
-			if (token$1.value === "") return ok(new KnownValue(0).taggedCbor());
-			const knownValue = knownValueForName(token$1.value);
+			if (token.value === "") return ok(new KnownValue(0).taggedCbor());
+			const knownValue = knownValueForName(token.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)));
+			return err(parseError.unknownKnownValueName(token.value, span(tokenSpan.start + 1, tokenSpan.end - 1)));
 		}
 		case "Unit": return ok(new KnownValue(0).taggedCbor());
 		case "BracketOpen": return parseArray(lexer);
@@ -887,7 +887,7 @@ function parseItemToken(token$1, lexer) {
 		case "ParenthesisOpen":
 		case "ParenthesisClose":
 		case "Colon":
-		case "Comma": return err(parseError.unexpectedToken(token$1, lexer.span()));
+		case "Comma": return err(parseError.unexpectedToken(token, lexer.span()));
 	}
 }
 function parseString(s, tokenSpan) {
@@ -946,15 +946,15 @@ function parseArray(lexer) {
 	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) {
+		const token = tokenResult.value;
+		if (token.type === "BracketClose" && !awaitsItem) return ok(cbor(items));
+		if (token.type === "Comma" && awaitsComma) {
 			awaitsItem = true;
 			awaitsComma = false;
 			continue;
 		}
 		if (awaitsComma) return err(parseError.expectedComma(lexer.span()));
-		const itemResult = parseItemToken(token$1, lexer);
+		const itemResult = parseItemToken(token, lexer);
 		if (!itemResult.ok) return itemResult;
 		items.push(itemResult.value);
 		awaitsItem = false;
@@ -971,15 +971,15 @@ function parseMap(lexer) {
 			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) {
+		const token = tokenResult.value;
+		if (token.type === "BraceClose" && !awaitsKey) return ok(cbor(map));
+		if (token.type === "Comma" && awaitsComma) {
 			awaitsKey = true;
 			awaitsComma = false;
 			continue;
 		}
 		if (awaitsComma) return err(parseError.expectedComma(lexer.span()));
-		const keyResult = parseItemToken(token$1, lexer);
+		const keyResult = parseItemToken(token, lexer);
 		if (!keyResult.ok) return keyResult;
 		const key = keyResult.value;
 		const keySpan = lexer.span();