@cbortech/cbor 0.25.2 → 0.25.4

package/dist/tokenizer-C597LW89.js

@@ -0,0 +1,995 @@
+//#region src/cdn/errors.ts
+var e = class extends SyntaxError {
+	offset;
+	line;
+	column;
+	endOffset;
+	constructor(e, t) {
+		let n = t?.line === void 0 ? "" : ` at line ${t.line}, column ${t.column}`;
+		super(`EDN parse error${n}: ${e}`), this.name = "CdnSyntaxError", this.offset = t?.offset, this.line = t?.line, this.column = t?.column, this.endOffset = t?.endOffset;
+	}
+};
+//#endregion
+//#region src/cdn/tokenizer.ts
+function t(e, t, n) {
+	let r = 1, i = 1;
+	for (let a = 0; a < e.length; a++) {
+		if (r === t && i === n) return a;
+		e[a] === "\n" ? (r++, i = 1) : i++;
+	}
+	return e.length;
+}
+function n(e, t) {
+	let n = 1, r = 1;
+	for (let i = 0; i < t; i++) e[i] === "\n" ? (n++, r = 1) : r++;
+	return {
+		line: n,
+		col: r
+	};
+}
+function r(e) {
+	return e >= 48 && e <= 57 || e >= 97 && e <= 102 || e >= 65 && e <= 70;
+}
+var i = new TextEncoder(), a = class {
+	input;
+	pos;
+	line;
+	col;
+	_peeked = null;
+	_lastConsumedEndOffset;
+	comments = [];
+	onEscapeWarning;
+	constructor(e, t) {
+		this.input = e;
+		let r = t?.offset ?? 0;
+		if (!Number.isInteger(r) || r < 0 || r > e.length) throw RangeError(`EDN parse offset must be an integer between 0 and ${e.length}`);
+		let i = n(e, r);
+		this.pos = r, this.line = i.line, this.col = i.col, this._lastConsumedEndOffset = r;
+	}
+	peek() {
+		return this._peeked === null && (this._peeked = this._readNext()), this._peeked;
+	}
+	consume() {
+		let e = this._peeked === null ? this._readNext() : this._peeked;
+		return this._peeked = null, this._lastConsumedEndOffset = e.endOffset, e;
+	}
+	get lastEndOffset() {
+		return this._lastConsumedEndOffset;
+	}
+	get source() {
+		return this.input;
+	}
+	_ch() {
+		return this.input[this.pos] ?? "";
+	}
+	_eof() {
+		return this.pos >= this.input.length;
+	}
+	_advance() {
+		let e = this.input[this.pos++] ?? "";
+		return e === "\n" ? (this.line++, this.col = 1) : this.col++, e;
+	}
+	_fail(n, r = this.line, i = this.col) {
+		throw new e(n, {
+			offset: r === this.line && i === this.col ? this.pos : t(this.input, r, i),
+			line: r,
+			column: i
+		});
+	}
+	_skipWS() {
+		for (;;) {
+			for (;;) {
+				let e = this.input[this.pos];
+				if (e === void 0) return;
+				if (e === " " || e === "\n" || e === "	" || e === "\r") {
+					this._advance();
+					continue;
+				}
+				if (e > " " && e <= "~") break;
+				if (/\s/.test(e)) {
+					this._advance();
+					continue;
+				}
+				break;
+			}
+			let e = this._ch();
+			if (e === "#") {
+				let e = this.pos, t = this.line, n = this.col;
+				for (; !this._eof() && this._ch() !== "\n";) this._advance();
+				this.comments.push({
+					kind: "line",
+					marker: "#",
+					text: this.input.slice(e, this.pos),
+					start: e,
+					end: this.pos,
+					line: t,
+					col: n
+				});
+				continue;
+			}
+			if (e === "/") {
+				let e = this.input[this.pos + 1] ?? "";
+				if (e === "/") {
+					let e = this.pos, t = this.line, n = this.col;
+					for (this._advance(), this._advance(); !this._eof() && this._ch() !== "\n";) this._advance();
+					this.comments.push({
+						kind: "line",
+						marker: "//",
+						text: this.input.slice(e, this.pos),
+						start: e,
+						end: this.pos,
+						line: t,
+						col: n
+					});
+					continue;
+				}
+				if (e === "*") {
+					let e = this.pos, t = this.line, n = this.col;
+					this._advance(), this._advance(), this._skipBlockCommentStar(), this.comments.push({
+						kind: "block",
+						marker: "/*",
+						text: this.input.slice(e, this.pos),
+						start: e,
+						end: this.pos,
+						line: t,
+						col: n
+					});
+					continue;
+				}
+				let t = this.pos, n = this.line, r = this.col;
+				this._advance(), this._skipBlockCommentSlash(), this.comments.push({
+					kind: "block",
+					marker: "/",
+					text: this.input.slice(t, this.pos),
+					start: t,
+					end: this.pos,
+					line: n,
+					col: r
+				});
+				continue;
+			}
+			return;
+		}
+	}
+	_skipByteStringComment(e) {
+		let t = this._ch();
+		if (t === "/") {
+			let t = this.input[this.pos + 1] ?? "";
+			if (t === "/") {
+				for (this._advance(), this._advance(); !this._eof() && this._ch() !== "\n";) {
+					if (this._ch() === "\\") {
+						this._advance(), !this._eof() && this._ch() !== "\n" && this._advance();
+						continue;
+					}
+					if (this._ch() === e) break;
+					this._advance();
+				}
+				return !0;
+			}
+			return t === "*" ? (this._advance(), this._advance(), this._skipBlockCommentStar(), !0) : (this._advance(), this._skipBlockCommentSlash(), !0);
+		}
+		if (t === "#") {
+			for (; !this._eof() && this._ch() !== "\n";) {
+				if (this._ch() === "\\") {
+					if (this._advance(), this._eof() || this._ch() === "\n") continue;
+					this._advance() === "u" && this._validateHexCommentUnicodeEscape();
+					continue;
+				}
+				if (this._ch() === e) break;
+				this._advance();
+			}
+			return !0;
+		}
+		return !1;
+	}
+	_validateHexCommentUnicodeEscape() {
+		let e = this.line, t = this.col;
+		if (!this._eof() && this._ch() === "{") {
+			this._advance();
+			let n = "";
+			for (; !this._eof() && this._ch() !== "}" && this._ch() !== "\n";) n += this._advance();
+			!this._eof() && this._ch() === "}" && this._advance();
+			let r = parseInt(n || "0", 16);
+			r >= 55296 && r <= 57343 && this._fail(`\\u{${n}} is a surrogate code point, not allowed in hex string comments`, e, t);
+			return;
+		}
+		let n = "";
+		for (let e = 0; e < 4 && !(this._eof() || this._ch() === "\n" || !/[0-9a-fA-F]/.test(this._ch())); e++) n += this._advance();
+		if (n.length < 4) return;
+		let r = parseInt(n, 16);
+		if (r >= 55296 && r <= 56319) {
+			(this._ch() !== "\\" || (this.input[this.pos + 1] ?? "") !== "u") && this._fail(`lone high surrogate \\u${n} in hex string comment`, e, t), this._advance(), this._advance();
+			let r = "";
+			for (let e = 0; e < 4 && !(this._eof() || this._ch() === "\n" || !/[0-9a-fA-F]/.test(this._ch())); e++) r += this._advance();
+			let i = parseInt(r || "0", 16);
+			(i < 56320 || i > 57343) && this._fail(`\\u${n} (high surrogate) not followed by valid low surrogate in hex string comment`, e, t);
+			return;
+		}
+		r >= 56320 && r <= 57343 && this._fail(`lone low surrogate \\u${n} in hex string comment`, e, t);
+	}
+	_skipRawComment(e, t, n, r, i) {
+		let a = e[t];
+		if (a === "/") {
+			if (t++, e[t] === "/") {
+				for (t++; t < e.length && e[t] !== "\n";) t++;
+				return t;
+			}
+			if (e[t] === "*") {
+				for (t++; t < e.length;) {
+					if (e[t] === "*" && e[t + 1] === "/") return t + 2;
+					t++;
+				}
+				return t;
+			}
+			for (; t < e.length && e[t] !== "/";) t++;
+			return t >= e.length && this._fail(`unterminated block comment in ${n}`, r, i), t + 1;
+		}
+		if (a === "#") {
+			for (; t < e.length && e[t] !== "\n";) t++;
+			return t;
+		}
+		return -1;
+	}
+	_skipBlockCommentSlash() {
+		let e = this.line, t = this.col;
+		for (; !this._eof();) {
+			if (this._ch() === "\\") {
+				this._advance(), this._eof() || this._advance();
+				continue;
+			}
+			if (this._ch() === "/") break;
+			this._advance();
+		}
+		this._eof() && this._fail("unterminated block comment", e, t), this._advance();
+	}
+	_skipBlockCommentStar() {
+		let e = this.line, t = this.col;
+		for (; !this._eof();) {
+			if (this._ch() === "*" && (this.input[this.pos + 1] ?? "") === "/") {
+				this._advance(), this._advance();
+				return;
+			}
+			this._advance();
+		}
+		this._fail("unterminated block comment", e, t);
+	}
+	_readStringContent(e) {
+		this._advance();
+		let t = e.charCodeAt(0), n = this.input.length, r = "";
+		for (; !this._eof() && this._ch() !== e;) {
+			let i = this.pos, a = 0, o = -1;
+			for (; i < n;) {
+				let e = this.input.charCodeAt(i);
+				if (e === t || e === 92 || e === 127) break;
+				if (e < 32) {
+					if (e !== 10) break;
+					a++, o = i;
+				}
+				i++;
+			}
+			if (i > this.pos) {
+				r += this.input.slice(this.pos, i), a > 0 ? (this.line += a, this.col = i - o) : this.col += i - this.pos, this.pos = i;
+				continue;
+			}
+			let s = this._ch();
+			if (s === "\r") {
+				this._advance();
+				continue;
+			}
+			let c = s.codePointAt(0);
+			if ((c < 32 && c !== 10 || c === 127) && this._fail(`unescaped control character U+${c.toString(16).padStart(4, "0")} is not allowed in string literals`), s === "\\") {
+				let t = this.pos, n = this.line, i = this.col;
+				this._advance();
+				let a = this._advance();
+				switch (a) {
+					case "n":
+						r += "\n";
+						break;
+					case "r":
+						r += "\r";
+						break;
+					case "t":
+						r += "	";
+						break;
+					case "b":
+						r += "\b";
+						break;
+					case "f":
+						r += "\f";
+						break;
+					case "\\":
+						r += "\\";
+						break;
+					case "u":
+						r += this._readUnicodeEscape(e, t, n, i);
+						break;
+					default:
+						if (a === e) {
+							r += a;
+							break;
+						}
+						if (a === "/") {
+							e === "'" && this._fail("\\/ is not a valid escape in single-quoted byte strings (§5.1)", n, i), r += "/";
+							break;
+						}
+						if (this.onEscapeWarning) {
+							if (a === "0") {
+								this.onEscapeWarning("\\0 is a non-standard escape sequence; use \\u0000 instead", t, n, i), r += "\0";
+								break;
+							}
+							if (a === "v") {
+								this.onEscapeWarning("\\v is a non-standard escape sequence; use \\u000b instead", t, n, i), r += "\v";
+								break;
+							}
+							if (a === "x") {
+								let e = this._ch(), a = this.input[this.pos + 1] ?? "";
+								(!/[0-9a-fA-F]/.test(e) || !/[0-9a-fA-F]/.test(a)) && this._fail("\\x escape requires exactly two hex digits", n, i), this._advance(), this._advance();
+								let o = parseInt(e + a, 16);
+								this.onEscapeWarning(`\\x${e}${a} is a non-standard escape sequence; use \\u00${e}${a} instead`, t, n, i), r += String.fromCharCode(o);
+								break;
+							}
+							if (a === "\"" || a === "'") {
+								this.onEscapeWarning(`\\${a} inside ${e === "\"" ? "double" : "single"}-quoted string is non-standard`, t, n, i), r += a;
+								break;
+							}
+							if (a === "\n" || a === "\r") {
+								a === "\r" && this._ch() === "\n" && this._advance(), this.onEscapeWarning("line continuation (\\<newline>) is non-standard; the newline is ignored", t, n, i);
+								break;
+							}
+							this.onEscapeWarning(`\\${a} is an unknown escape sequence; interpreted as '${a}'`, t, n, i), r += a;
+							break;
+						}
+						this._fail(`invalid escape sequence \\${a} in ${e === "\"" ? "double" : "single"}-quoted string`, n, i);
+				}
+			} else r += this._advance();
+		}
+		return this._eof() && this._fail("unterminated string literal"), this._advance(), r;
+	}
+	_readUnicodeEscape(e, t, n, r) {
+		let i = this.line, a = this.col, o = (o) => {
+			if (e === "'" && o >= 32 && o <= 126) {
+				let e = `\\u escape for printable ASCII U+${o.toString(16).padStart(4, "0").toUpperCase()} is not allowed in single-quoted strings (§5.1 hexchar-s)`;
+				if (this.onEscapeWarning) {
+					this.onEscapeWarning(e, t ?? this.pos, n ?? i, r ?? a);
+					return;
+				}
+				this._fail(e, i, a);
+			}
+		};
+		if (!this._eof() && this._ch() === "{") {
+			this._advance();
+			let e = "";
+			for (; !this._eof() && this._ch() !== "}";) {
+				let t = this._ch();
+				/[0-9a-fA-F]/.test(t) || this._fail(`invalid character in \\u{} escape: ${JSON.stringify(t)}`, i, a), e += this._advance();
+			}
+			this._eof() && this._fail("unterminated \\u{} escape", i, a), this._advance(), e.length === 0 && this._fail("empty \\u{} escape", i, a);
+			let t = parseInt(e, 16);
+			return t > 1114111 && this._fail(`\\u{${e}} exceeds maximum Unicode code point U+10FFFF`, i, a), t >= 55296 && t <= 57343 && this._fail(`\\u{${e}} is a surrogate code point, which is not a valid Unicode scalar value`, i, a), o(t), String.fromCodePoint(t);
+		}
+		let s = "";
+		for (let e = 0; e < 4; e++) {
+			this._eof() && this._fail("truncated \\uXXXX escape", i, a);
+			let e = this._ch();
+			/[0-9a-fA-F]/.test(e) || this._fail(`invalid hex digit in \\uXXXX escape: ${JSON.stringify(e)}`, i, a), s += this._advance();
+		}
+		let c = parseInt(s, 16);
+		if (c >= 55296 && c <= 56319) {
+			(this._ch() !== "\\" || (this.input[this.pos + 1] ?? "") !== "u") && this._fail(`lone high surrogate \\u${s} must be followed by \\uDC00–\\uDFFF`, i, a), this._advance(), this._advance();
+			let e = this.line, t = this.col, n = "";
+			for (let r = 0; r < 4; r++) this._eof() && this._fail("truncated low-surrogate escape", e, t), n += this._advance();
+			let r = parseInt(n, 16);
+			return (r < 56320 || r > 57343) && this._fail(`\\u${s} (high surrogate) not followed by a valid low surrogate (got \\u${n})`, i, a), String.fromCodePoint(65536 + (c - 55296) * 1024 + (r - 56320));
+		}
+		return c >= 56320 && c <= 57343 && this._fail(`lone low surrogate \\u${s} is not valid`, i, a), o(c), String.fromCharCode(c);
+	}
+	_readRawStringContent() {
+		let e = this.line, t = this.col, n = 0;
+		for (; !this._eof() && this._ch() === "`";) this._advance(), n++;
+		!this._eof() && this._ch() === "\r" && this._advance(), !this._eof() && this._ch() === "\n" && this._advance();
+		let r = this.input.length, i = "";
+		for (; !this._eof();) {
+			let a = this.pos, o = 0, s = -1;
+			for (; a < r;) {
+				let e = this.input.charCodeAt(a);
+				if (e === 96 || e === 127) break;
+				if (e < 32) {
+					if (e !== 10) break;
+					o++, s = a;
+				}
+				a++;
+			}
+			if (a > this.pos) {
+				i += this.input.slice(this.pos, a), o > 0 ? (this.line += o, this.col = a - s) : this.col += a - this.pos, this.pos = a;
+				continue;
+			}
+			let c = this._ch();
+			if (c === "\r") {
+				this._advance();
+				continue;
+			}
+			if (c === "`") {
+				let r = 0;
+				for (; !this._eof() && this._ch() === "`";) this._advance(), r++;
+				if (r >= n) return i += "`".repeat(r - n), i === "" && this._fail("raw string must not be empty (§2.5.3)", e, t), i;
+				i += "`".repeat(r);
+			} else {
+				let e = c.codePointAt(0);
+				e < 32 && e !== 10 && e !== 13 && this._fail(`raw string content must not contain control character U+${e.toString(16).toUpperCase().padStart(4, "0")} (§2.5.3)`, this.line, this.col), e === 127 && this._fail("raw string content must not contain DEL (U+007F) (§2.5.3)", this.line, this.col), i += this._advance();
+			}
+		}
+		this._fail("unterminated raw string literal", e, t);
+	}
+	_processRawHexContent(e, t, n) {
+		let i = "", a = !1, o = 0;
+		for (; o < e.length;) {
+			let s = e[o];
+			if (s === "\n" || s === " " || s === "\r") {
+				o++;
+				continue;
+			}
+			s === "	" && this._fail("horizontal tab (HT) is not allowed inside h`` raw byte string literals (§5.3.3)", t, n);
+			let c = this._skipRawComment(e, o, "h`` raw byte string", t, n);
+			if (c !== -1) {
+				o = c;
+				continue;
+			}
+			if (s === "." && e[o + 1] === "." && e[o + 2] === ".") {
+				for (o += 3; o < e.length && e[o] === ".";) o++;
+				i += "...", a = !0;
+				continue;
+			}
+			if (r(e.charCodeAt(o))) {
+				let t = o;
+				for (; o < e.length && r(e.charCodeAt(o));) o++;
+				i += e.slice(t, o);
+				continue;
+			}
+			this._fail(`unexpected character ${JSON.stringify(s)} in h\`\` raw byte string`, t, n);
+		}
+		return {
+			value: i,
+			elided: a
+		};
+	}
+	_processRawB64Content(e, t, n) {
+		let r = "", i = 0;
+		for (; i < e.length;) {
+			let a = e[i];
+			if (a === "\n" || a === " " || a === "\r") {
+				i++;
+				continue;
+			}
+			if (a === "	" && this._fail("horizontal tab (HT) is not allowed inside b64`` raw byte string literals (§5.3.4)", t, n), a === "#") {
+				for (; i < e.length && e[i] !== "\n";) i++;
+				continue;
+			}
+			let o = i;
+			for (; i < e.length;) {
+				let t = e[i];
+				if (t === "\n" || t === " " || t === "\r" || t === "	" || t === "#") break;
+				i++;
+			}
+			r += e.slice(o, i);
+		}
+		return r;
+	}
+	_readByteContent(e) {
+		this._advance();
+		let t = "";
+		for (; !this._eof() && this._ch() !== e;) {
+			let n = this._ch();
+			if (n === "\n" || n === " ") {
+				this._advance();
+				continue;
+			}
+			if (n === "\r") {
+				this._advance();
+				continue;
+			}
+			if (n === "	" && this._fail("horizontal tab (HT) is not allowed inside byte string literals (§5.2.2)", this.line, this.col), n === "#") {
+				for (; !this._eof() && this._ch() !== "\n";) {
+					if (this._ch() === "\\") {
+						this._advance(), !this._eof() && this._ch() !== "\n" && this._advance();
+						continue;
+					}
+					if (this._ch() === e) break;
+					this._advance();
+				}
+				continue;
+			}
+			let r = this.pos, i = this.pos, a = this.input.length;
+			for (; i < a;) {
+				let t = this.input[i];
+				if (t === e || t === "\n" || t === " " || t === "\r" || t === "	" || t === "#") break;
+				i++;
+			}
+			this.col += i - r, this.pos = i, t += this.input.slice(r, i);
+		}
+		return this._eof() && this._fail("unterminated byte string literal"), this._advance(), t;
+	}
+	_readHexByteContentElisionAware(e) {
+		this._advance();
+		let t = "", n = !1;
+		for (; !this._eof() && this._ch() !== e;) {
+			let i = this._ch();
+			if (i === "\n" || i === " " || i === "\r") {
+				this._advance();
+				continue;
+			}
+			if (i === "	" && this._fail("horizontal tab (HT) is not allowed inside hex byte string literals (§5.2.1)", this.line, this.col), !this._skipByteStringComment(e)) {
+				if (i === "." && (this.input[this.pos + 1] ?? "") === "." && (this.input[this.pos + 2] ?? "") === ".") {
+					for (this._advance(), this._advance(), this._advance(); !this._eof() && this._ch() === ".";) this._advance();
+					t.endsWith("...") || (t += "..."), n = !0;
+					continue;
+				}
+				if (r(i.charCodeAt(0))) {
+					let e = this.pos, n = this.pos, i = this.input.length;
+					for (; n < i && r(this.input.charCodeAt(n));) n++;
+					this.col += n - e, this.pos = n, t += this.input.slice(e, n);
+					continue;
+				}
+				this._fail(`unexpected character ${JSON.stringify(i)} in hex byte string`);
+			}
+		}
+		return this._eof() && this._fail("unterminated hex byte string literal"), this._advance(), {
+			value: t,
+			elided: n
+		};
+	}
+	_readNext() {
+		this._skipWS();
+		let e = this.pos;
+		return {
+			...this._readNextCore(),
+			raw: this.input.slice(e, this.pos),
+			offset: e,
+			endOffset: this.pos
+		};
+	}
+	_readNextCore() {
+		let e = this.line, t = this.col;
+		if (this._eof()) return {
+			type: "EOF",
+			value: "",
+			line: e,
+			col: t
+		};
+		let n = this._ch();
+		switch (n) {
+			case "[": return this._advance(), {
+				type: "LBRACKET",
+				value: "[",
+				line: e,
+				col: t
+			};
+			case "]": return this._advance(), {
+				type: "RBRACKET",
+				value: "]",
+				line: e,
+				col: t
+			};
+			case "{": return this._advance(), {
+				type: "LBRACE",
+				value: "{",
+				line: e,
+				col: t
+			};
+			case "}": return this._advance(), {
+				type: "RBRACE",
+				value: "}",
+				line: e,
+				col: t
+			};
+			case "(": return this._advance(), {
+				type: "LPAREN",
+				value: "(",
+				line: e,
+				col: t
+			};
+			case ")": return this._advance(), {
+				type: "RPAREN",
+				value: ")",
+				line: e,
+				col: t
+			};
+			case ":": return this._advance(), {
+				type: "COLON",
+				value: ":",
+				line: e,
+				col: t
+			};
+			case ",": return this._advance(), {
+				type: "COMMA",
+				value: ",",
+				line: e,
+				col: t
+			};
+			case "<":
+				if ((this.input[this.pos + 1] ?? "") === "<") return this._advance(), this._advance(), {
+					type: "LT_LT",
+					value: "<<",
+					line: e,
+					col: t
+				};
+				this._fail("unexpected character '<'", e, t);
+			case ">":
+				if ((this.input[this.pos + 1] ?? "") === ">") return this._advance(), this._advance(), {
+					type: "GT_GT",
+					value: ">>",
+					line: e,
+					col: t
+				};
+				this._fail("unexpected character '>'", e, t);
+			case "+": {
+				let n = this._readSignedInfinity("+", e, t);
+				if (n !== null) return n;
+				let r = this.input[this.pos + 1] ?? "";
+				return r >= "0" && r <= "9" || r === "." ? (this._advance(), this._readNumber(e, t)) : (this._advance(), {
+					type: "PLUS",
+					value: "+",
+					line: e,
+					col: t
+				});
+			}
+			case "`": return {
+				type: "RAWSTRING",
+				value: this._readRawStringContent(),
+				line: e,
+				col: t
+			};
+			case "\"": {
+				let n = this._readStringContent("\"");
+				return n === "" && this._ch() === "_" ? (this._advance(), {
+					type: "EMPTY_INDEF_TEXT",
+					value: "",
+					line: e,
+					col: t
+				}) : {
+					type: "TSTR",
+					value: n,
+					line: e,
+					col: t
+				};
+			}
+			case "'": {
+				if ((this.input[this.pos + 1] ?? "") === "'" && (this.input[this.pos + 2] ?? "") === "_") return this._advance(), this._advance(), this._advance(), {
+					type: "EMPTY_INDEF_BYTES",
+					value: "",
+					line: e,
+					col: t
+				};
+				let n = this._readStringContent("'"), r = i.encode(n);
+				return {
+					type: "SQSTR",
+					value: Array.from(r, (e) => e.toString(16).padStart(2, "0")).join(""),
+					line: e,
+					col: t
+				};
+			}
+		}
+		if (n === "-") {
+			let n = this._readSignedInfinity("-", e, t);
+			return n === null ? this._readNumber(e, t) : n;
+		}
+		if (n >= "0" && n <= "9" || n === "." && /[0-9]/.test(this.input[this.pos + 1] ?? "")) return this._readNumber(e, t);
+		if (/[a-zA-Z_]/.test(n)) return this._readIdent(e, t);
+		if (n === ".") {
+			if ((this.input[this.pos + 1] ?? "") === "." && (this.input[this.pos + 2] ?? "") === ".") {
+				for (this._advance(), this._advance(), this._advance(); !this._eof() && this._ch() === ".";) this._advance();
+				return {
+					type: "ELLIPSIS",
+					value: "...",
+					line: e,
+					col: t
+				};
+			}
+			this._fail("unexpected character '.'", e, t);
+		}
+		this._fail(`unexpected character ${JSON.stringify(n)}`, e, t);
+	}
+	_readSignedInfinity(e, t, n) {
+		if (!this.input.startsWith("Infinity", this.pos + 1)) return null;
+		let r = this.input[this.pos + 9] ?? "", i = r === "_" && /[0-7i]/.test(this.input[this.pos + 10] ?? "") && !/[a-zA-Z0-9_]/.test(this.input[this.pos + 11] ?? "");
+		if (/[a-zA-Z0-9_]/.test(r) && !i) return null;
+		this._advance();
+		for (let e = 0; e < 8; e++) this._advance();
+		let a = e === "-" ? "-Infinity" : "Infinity";
+		return i && (a += this._advance() + this._advance()), {
+			type: "FLOAT",
+			value: a,
+			line: t,
+			col: n
+		};
+	}
+	_skipHexDigits() {
+		let e = this.pos, t = this.input.length;
+		for (; e < t && r(this.input.charCodeAt(e));) e++;
+		this.col += e - this.pos, this.pos = e;
+	}
+	_skipDecimalDigits() {
+		let e = this.pos, t = this.input.length;
+		for (; e < t;) {
+			let t = this.input.charCodeAt(e);
+			if (t < 48 || t > 57) break;
+			e++;
+		}
+		this.col += e - this.pos, this.pos = e;
+	}
+	_tryConsumeEncodingSuffix() {
+		if (this._ch() !== "_") return;
+		let e = this.input[this.pos + 1] ?? "", t = this.input[this.pos + 2] ?? "";
+		(e >= "0" && e <= "7" || e === "i") && !/[0-9a-zA-Z_]/.test(t) && (this._advance(), this._advance());
+	}
+	_readNumber(e, t) {
+		let n = this.pos, r = () => this.input.slice(n, this.pos);
+		if (this._ch() === "-" && this._advance(), this._ch() === "0") {
+			let n = this.input[this.pos + 1] ?? "";
+			if (n === "x" || n === "X") {
+				this._advance(), this._advance();
+				let n = this.pos;
+				this._skipHexDigits();
+				let i = this.pos > n, a = !1, o = !1;
+				if (!this._eof() && this._ch() === ".") {
+					a = !0, this._advance();
+					let e = this.pos;
+					this._skipHexDigits(), o = this.pos > e;
+				}
+				if (!this._eof() && (this._ch() === "p" || this._ch() === "P")) {
+					a = !0, !i && !o && this._fail(`hex float has no mantissa digits: ${r()}`, e, t), this._advance(), !this._eof() && (this._ch() === "+" || this._ch() === "-") && this._advance();
+					let n = this.pos;
+					this._skipDecimalDigits(), this.pos === n && this._fail(`hex float missing exponent digits: ${r()}`, e, t);
+				} else a && this._fail(`hex float missing 'p' exponent: ${r()}`, e, t);
+				return a ? (this._tryConsumeEncodingSuffix(), {
+					type: "FLOAT",
+					value: r(),
+					line: e,
+					col: t
+				}) : {
+					type: "INTEGER",
+					value: r(),
+					line: e,
+					col: t
+				};
+			}
+			if (n === "o" || n === "O") {
+				for (this._advance(), this._advance(); !this._eof() && this._ch() >= "0" && this._ch() <= "7";) this._advance();
+				return {
+					type: "INTEGER",
+					value: r(),
+					line: e,
+					col: t
+				};
+			}
+			if (n === "b" || n === "B") {
+				for (this._advance(), this._advance(); !this._eof() && (this._ch() === "0" || this._ch() === "1");) this._advance();
+				return {
+					type: "INTEGER",
+					value: r(),
+					line: e,
+					col: t
+				};
+			}
+		}
+		this._skipDecimalDigits();
+		let i = !1;
+		if (!this._eof() && this._ch() === "." && (i = !0, this._advance(), this._skipDecimalDigits()), !this._eof() && (this._ch() === "e" || this._ch() === "E")) {
+			i = !0, this._advance(), !this._eof() && (this._ch() === "+" || this._ch() === "-") && this._advance();
+			let n = this.pos;
+			this._skipDecimalDigits(), this.pos === n && this._fail(`float exponent has no digits: ${JSON.stringify(r())}`, e, t);
+		}
+		return this._tryConsumeEncodingSuffix(), {
+			type: i ? "FLOAT" : "INTEGER",
+			value: r(),
+			line: e,
+			col: t
+		};
+	}
+	_readIdent(e, t) {
+		let n = this.pos;
+		{
+			let e = this.pos, t = this.input.length;
+			for (; e < t;) {
+				let t = this.input.charCodeAt(e);
+				if (!(t >= 97 && t <= 122 || t >= 65 && t <= 90 || t >= 48 && t <= 57 || t === 95)) break;
+				e++;
+			}
+			this.col += e - this.pos, this.pos = e;
+		}
+		let r = this.input.slice(n, this.pos);
+		switch (r) {
+			case "true": return {
+				type: "TRUE",
+				value: r,
+				line: e,
+				col: t
+			};
+			case "false": return {
+				type: "FALSE",
+				value: r,
+				line: e,
+				col: t
+			};
+			case "null": return {
+				type: "NULL",
+				value: r,
+				line: e,
+				col: t
+			};
+			case "undefined": return {
+				type: "UNDEFINED",
+				value: r,
+				line: e,
+				col: t
+			};
+			case "NaN":
+			case "NaN_0":
+			case "NaN_1":
+			case "NaN_2":
+			case "NaN_3":
+			case "NaN_4":
+			case "NaN_5":
+			case "NaN_6":
+			case "NaN_7":
+			case "NaN_i":
+			case "Infinity":
+			case "Infinity_0":
+			case "Infinity_1":
+			case "Infinity_2":
+			case "Infinity_3":
+			case "Infinity_4":
+			case "Infinity_5":
+			case "Infinity_6":
+			case "Infinity_7":
+			case "Infinity_i": return {
+				type: "FLOAT",
+				value: r,
+				line: e,
+				col: t
+			};
+			case "simple": return {
+				type: "SIMPLE",
+				value: r,
+				line: e,
+				col: t
+			};
+			case "_": return {
+				type: "UNDERSCORE",
+				value: "_",
+				line: e,
+				col: t
+			};
+			case "_0": return {
+				type: "ENCODING_INDICATOR",
+				value: "0",
+				line: e,
+				col: t
+			};
+			case "_1": return {
+				type: "ENCODING_INDICATOR",
+				value: "1",
+				line: e,
+				col: t
+			};
+			case "_2": return {
+				type: "ENCODING_INDICATOR",
+				value: "2",
+				line: e,
+				col: t
+			};
+			case "_3": return {
+				type: "ENCODING_INDICATOR",
+				value: "3",
+				line: e,
+				col: t
+			};
+			case "_4": return {
+				type: "ENCODING_INDICATOR",
+				value: "4",
+				line: e,
+				col: t
+			};
+			case "_5": return {
+				type: "ENCODING_INDICATOR",
+				value: "5",
+				line: e,
+				col: t
+			};
+			case "_6": return {
+				type: "ENCODING_INDICATOR",
+				value: "6",
+				line: e,
+				col: t
+			};
+			case "_7": return {
+				type: "ENCODING_INDICATOR",
+				value: "7",
+				line: e,
+				col: t
+			};
+			case "_i": return {
+				type: "ENCODING_INDICATOR",
+				value: "i",
+				line: e,
+				col: t
+			};
+		}
+		let i = r[0] ?? "", a = i >= "a" && i <= "z";
+		if (a || i >= "A" && i <= "Z") {
+			let n = r.slice(1);
+			if (a ? /^[a-z0-9]*$/.test(n) : /^[A-Z0-9]*$/.test(n)) {
+				let n = this.pos;
+				for (; !this._eof();) {
+					let e = this._ch();
+					if (!(a ? e >= "a" && e <= "z" || e >= "0" && e <= "9" || e === "-" : e >= "A" && e <= "Z" || e >= "0" && e <= "9" || e === "-")) break;
+					this.pos++;
+				}
+				this.pos > n && (this.col += this.pos - n, r += this.input.slice(n, this.pos));
+				let i = this._ch();
+				if (i === "\"" && this._fail(`"${r}" prefix requires single quotes or backticks, not double quotes`, e, t), i === "'") switch (r) {
+					case "h": {
+						let { value: n, elided: r } = this._readHexByteContentElisionAware(i);
+						return {
+							type: r ? "BYTES_HEX_ELIDED" : "BYTES_HEX",
+							value: n,
+							line: e,
+							col: t
+						};
+					}
+					case "b64": return {
+						type: "BYTES_B64",
+						value: this._readByteContent(i),
+						line: e,
+						col: t
+					};
+					default: return {
+						type: "APP_STRING",
+						appPrefix: r,
+						value: this._readStringContent(i),
+						line: e,
+						col: t
+					};
+				}
+				if (i === "`") {
+					let n = this._readRawStringContent();
+					switch (r) {
+						case "h": {
+							let { value: r, elided: i } = this._processRawHexContent(n, e, t);
+							return {
+								type: i ? "BYTES_HEX_ELIDED" : "BYTES_HEX",
+								value: r,
+								line: e,
+								col: t
+							};
+						}
+						case "b64": return {
+							type: "BYTES_B64",
+							value: this._processRawB64Content(n, e, t),
+							line: e,
+							col: t
+						};
+						default: return {
+							type: "APP_STRING",
+							appPrefix: r,
+							value: n,
+							line: e,
+							col: t
+						};
+					}
+				}
+				if (i === "<" && (this.input[this.pos + 1] ?? "") === "<") return this._advance(), this._advance(), {
+					type: "APP_SEQUENCE",
+					appPrefix: r,
+					value: "",
+					line: e,
+					col: t
+				};
+			}
+		}
+		this._fail(`unknown identifier ${JSON.stringify(r)}`, e, t);
+	}
+};
+//#endregion
+export { e as n, a as t };
+
+//# sourceMappingURL=tokenizer-C597LW89.js.map