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

package/dist/index.iife.js

@@ -27,120 +27,120 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 		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
 			};
 		}
 	};
@@ -310,8 +310,8 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 		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
@@ -436,65 +436,65 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 	* 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)],
@@ -504,23 +504,23 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 				["-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 = _bcts_dcbor.CborDate.fromString(dateStr);
@@ -530,91 +530,91 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 				}
 			}
 		}
-		#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);
@@ -623,47 +623,47 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 				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 = _bcts_uniform_resources.UR.fromURString(fullMatch);
 					return ok(token.ur(ur));
@@ -673,8 +673,8 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 				}
 			}
 		}
-		#tryMatchPunctuation() {
-			const ch = this.#source[this.#position];
+		_tryMatchPunctuation() {
+			const ch = this._source[this._position];
 			const matched = {
 				"{": token.braceOpen(),
 				"}": token.braceClose(),
@@ -686,19 +686,19 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 				",": 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);
 		}
 	};
@@ -855,28 +855,28 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 		}
 		return result;
 	}
-	function parseItemToken(token$1, lexer) {
-		switch (token$1.type) {
-			case "Bool": return ok((0, _bcts_dcbor.cbor)(token$1.value));
+	function parseItemToken(token, lexer) {
+		switch (token.type) {
+			case "Bool": return ok((0, _bcts_dcbor.cbor)(token.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 "ByteStringHex": return ok((0, _bcts_dcbor.cbor)(token.value));
+			case "ByteStringBase64": return ok((0, _bcts_dcbor.cbor)(token.value));
+			case "DateLiteral": return ok((0, _bcts_dcbor.cbor)(token.value));
+			case "Number": return ok((0, _bcts_dcbor.cbor)(token.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 "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 _bcts_known_values.KnownValue(token.value).taggedCbor());
 			case "KnownValueName": {
-				if (token$1.value === "") return ok(new _bcts_known_values.KnownValue(0).taggedCbor());
-				const knownValue = knownValueForName(token$1.value);
+				if (token.value === "") return ok(new _bcts_known_values.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 _bcts_known_values.KnownValue(0).taggedCbor());
 			case "BracketOpen": return parseArray(lexer);
@@ -886,7 +886,7 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 			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) {
@@ -945,15 +945,15 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 		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) {
+			const token = tokenResult.value;
+			if (token.type === "BracketClose" && !awaitsItem) return ok((0, _bcts_dcbor.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;
@@ -970,15 +970,15 @@ var bctsDcborParse = (function(exports, _bcts_dcbor, _bcts_known_values, _bcts_u
 				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) {
+			const token = tokenResult.value;
+			if (token.type === "BraceClose" && !awaitsKey) return ok((0, _bcts_dcbor.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();