soml-lang 0.0.1

package/source/parse.js

@@ -0,0 +1,1574 @@
+import {ParseError} from './error.js';
+import {
+	MAX_DEPTH,
+	INT64_MIN,
+	INT64_MAX,
+	MIN_INSTANT,
+	MAX_INSTANT,
+	DURATION_UNITS,
+	createDuration,
+	trimTrailingZeros,
+	validateIntegersOption,
+	describeCharacter,
+	formatCodePoint,
+	isBareKey,
+	bareKeyCharacters,
+	abbreviate,
+} from './shared.js';
+
+const TAB = 0x09;
+const LF = 0x0A;
+const SPACE = 0x20;
+const DOUBLE_QUOTE = 0x22;
+const HASH = 0x23;
+const SINGLE_QUOTE = 0x27;
+const ASTERISK = 0x2A;
+const COMMA = 0x2C;
+const DASH = 0x2D;
+const DOT = 0x2E;
+const SLASH = 0x2F;
+const COLON = 0x3A;
+const OPEN_BRACKET = 0x5B;
+const CLOSE_BRACKET = 0x5D;
+const OPEN_BRACE = 0x7B;
+const CLOSE_BRACE = 0x7D;
+
+/*
+What may directly follow a scalar value: whitespace, a separator, a closing bracket, a comment, or the end.
+*/
+const valueEndCharacters = new Uint8Array(128);
+
+for (const character of ' \t\n,]}#/') {
+	valueEndCharacters[character.codePointAt(0)] = 1;
+}
+
+/*
+A number, an instant, or a duration is lexed as one maximal run of these characters, and then validated as a whole. The validation is a hand-written scan rather than a regular expression, because a regular expression with a repeated group runs out of stack on a token of a few million characters.
+*/
+const numberCharacters = new Uint8Array(128);
+
+for (const character of 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.:+-') {
+	numberCharacters[character.codePointAt(0)] = 1;
+}
+
+const RADIX_DIGIT = {
+	x: code => (code >= 0x30 && code <= 0x39) || (code >= 0x41 && code <= 0x46),
+	o: code => code >= 0x30 && code <= 0x37,
+	b: code => code === 0x30 || code === 0x31,
+};
+
+/*
+The longest token the diagnostic regular expressions look at. Their repeated groups need stack in proportion to the input, so a longer invalid token is described from its first part.
+*/
+const MAX_DIAGNOSED_LENGTH = 1000;
+
+const RADIX_NAME = {x: 'hexadecimal', o: 'octal', b: 'binary'};
+const RADIX_ARTICLE = {x: 'A', o: 'An', b: 'A'};
+const INSTANT_PREFIX = /^\d{4}-\d{2}-\d{2}/v;
+const DURATION_UNIT_NAMES = DURATION_UNITS.keys().toArray();
+const INSTANT = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T(?<hour>\d{2}):(?<minute>\d{2}):(?<second>\d{2})(?:\.(?<fraction>\d+))?(?<offset>Z|[+\-](?<offsetHour>\d{2}):(?<offsetMinute>\d{2}))$/v;
+const UNICODE_ESCAPE = /u\{(?<hex>[\da-f]{1,6})\}/vy;
+/*
+Every C0 control character except tab and line feed, and DEL. They are errors anywhere in a document.
+*/
+// eslint-disable-next-line no-control-regex, regexp/no-control-character -- Control characters are exactly what must be found.
+const CONTROL_CHARACTER = /[\u{0}-\u{8}\u{B}-\u{1F}\u{7F}]/v;
+const LITERAL_STRING_END = /[\n']/gv;
+const BLANK_LINE = /^[\t ]*$/v;
+const ESCAPED_STRING_SPECIAL = /[\n"\\]/gv;
+
+const SIMPLE_ESCAPES = {
+	'\\': '\\',
+	'"': '"',
+	n: '\n',
+	t: '\t',
+};
+
+/**
+Parse a document.
+
+@param {string | Uint8Array} text
+@param {{integers?: 'bigint' | 'number'}} [options]
+*/
+export function parse(text, options = {}) {
+	const {integers = 'bigint'} = options;
+	validateIntegersOption(integers);
+	const source = decode(text);
+	checkCharacters(source);
+	return new Parser(source, integers).parseDocument();
+}
+
+const typedArrayTag = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag).get;
+
+function decode(text) {
+	if (typeof text === 'string') {
+		return text;
+	}
+
+	// A brand check rather than `instanceof`, so that bytes from another realm, such as a `vm` context, are accepted too. The typed array tag getter reads an internal slot, so it cannot be faked with `Symbol.toStringTag`.
+	if (typedArrayTag.call(text) === 'Uint8Array') {
+		try {
+			// `ignoreBOM` keeps a BOM in the output, so that it can be rejected rather than silently dropped.
+			return new TextDecoder('utf-8', {fatal: true, ignoreBOM: true}).decode(text);
+		} catch (error) {
+			const offset = findInvalidUtf8(text);
+
+			// Every byte is valid, so the decoder failed for another reason, such as input longer than the longest possible string.
+			if (offset === text.length) {
+				throw error;
+			}
+
+			const valid = new TextDecoder('utf-8', {ignoreBOM: true}).decode(text.subarray(0, offset));
+
+			// A sequence that the end of the input cuts short decodes without error when more bytes may follow.
+			if (isTruncatedUtf8(text.subarray(offset))) {
+				throw new ParseError('Incomplete UTF-8 sequence at the end of the input', valid, valid.length);
+			}
+
+			throw new ParseError(`Invalid UTF-8 byte 0x${text[offset].toString(16).toUpperCase().padStart(2, '0')}`, valid, valid.length);
+		}
+	}
+
+	throw new TypeError(`Expected a string or a Uint8Array, got ${typeof text === 'object' ? (text === null ? 'null' : 'an object') : typeof text}`);
+}
+
+/*
+Finds the first byte of the first invalid sequence. Only called on the error path, so each multi-byte sequence is checked with a fatal decoder rather than by reimplementing the UTF-8 rules for overlong forms, surrogates, and the U+10FFFF limit.
+*/
+function findInvalidUtf8(bytes) {
+	const decoder = new TextDecoder('utf-8', {fatal: true, ignoreBOM: true});
+	let index = 0;
+
+	while (index < bytes.length) {
+		const byte = bytes[index];
+
+		if (byte < 0x80) {
+			index++;
+			continue;
+		}
+
+		const length = byte >= 0xF0 ? 4 : (byte >= 0xE0 ? 3 : 2);
+		const sequence = bytes.subarray(index, index + length);
+
+		// A fatal decode also throws for a sequence that the end of the input cuts short.
+		try {
+			decoder.decode(sequence);
+		} catch {
+			return index;
+		}
+
+		index += length;
+	}
+
+	return index;
+}
+
+function isTruncatedUtf8(bytes) {
+	try {
+		new TextDecoder('utf-8', {fatal: true}).decode(bytes, {stream: true});
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/*
+Characters that are errors wherever they appear, so they are checked once, up front.
+*/
+function checkCharacters(source) {
+	if (source.charCodeAt(0) === 0xFE_FF) {
+		throw new ParseError('A byte order mark (BOM) is not allowed', source, 0);
+	}
+
+	const control = CONTROL_CHARACTER.exec(source);
+
+	if (control !== null) {
+		const {index} = control;
+		const code = source.charCodeAt(index);
+
+		if (code === 0x0D) {
+			throw new ParseError('A carriage return (U+000D) is not allowed anywhere. Use LF line endings', source, index);
+		}
+
+		const escape = String.raw`\u{${code.toString(16)}}`;
+		throw new ParseError(`A raw control character (${formatCodePoint(code)}) is not allowed anywhere, including in strings and comments. In a string, write it as the escape ${escape} inside "..."`, source, index);
+	}
+
+	if (!source.isWellFormed()) {
+		// With the `v` flag, a surrogate in the class matches only when it is unpaired.
+		const offset = /[\u{D800}-\u{DFFF}]/v.exec(source).index;
+		throw new ParseError(`A lone surrogate (${describeCharacter(source.charCodeAt(offset))}) is not a Unicode scalar value`, source, offset);
+	}
+}
+
+/*
+Creates an own property without ever invoking a setter, like `JSON.parse`. Plain assignment is used when `Object.prototype` has no property of that name, which is the fast common case. Otherwise, as for `__proto__`, `toString`, or anything a library added to the prototype, assignment would call a setter or fail on a frozen prototype.
+*/
+function defineMember(object, key, value) {
+	if (Reflect.has(Object.prototype, key)) {
+		Object.defineProperty(object, key, {
+			value,
+			writable: true,
+			enumerable: true,
+			configurable: true,
+		});
+	} else {
+		object[key] = value;
+	}
+}
+
+function describeValue(value) {
+	if (Array.isArray(value)) {
+		return 'an array';
+	}
+
+	return value !== null && typeof value === 'object' && !(value instanceof Temporal.Instant) && !(value instanceof Temporal.Duration) ? 'an object' : 'a value';
+}
+
+function formatPath(path) {
+	return path.map(segment => isBareKey(segment) ? abbreviate(segment) : JSON.stringify(abbreviate(segment))).join('.');
+}
+
+class Parser {
+	#source;
+	#index = 0;
+	#integers;
+	/*
+	Objects created by dotted keys. They may be extended by further dotted keys, while an object written with braces is closed.
+	*/
+	#dottedObjects = new WeakSet();
+
+	constructor(source, integers) {
+		this.#source = source;
+		this.#integers = integers;
+	}
+
+	#fail(reason, offset = this.#index) {
+		throw new ParseError(reason, this.#source, offset);
+	}
+
+	#code(offset = this.#index) {
+		return this.#source.charCodeAt(offset);
+	}
+
+	#isAtEnd() {
+		return this.#index >= this.#source.length;
+	}
+
+	parseDocument() {
+		this.#skipTrivia();
+
+		if (this.#isAtEnd()) {
+			this.#fail('A document must contain an object or an array, but this one is empty');
+		}
+
+		const code = this.#code();
+		let value;
+
+		if (code === OPEN_BRACE) {
+			value = this.#parseObject(1);
+		} else if (code === OPEN_BRACKET) {
+			value = this.#parseArray(1);
+		} else {
+			value = this.#parseBareObject();
+		}
+
+		this.#skipTrivia();
+
+		if (!this.#isAtEnd()) {
+			this.#fail(`Unexpected ${this.#describeHere()} after the end of the document`);
+		}
+
+		return value;
+	}
+
+	/*
+	`bare-object = removable entry ( entry-sep removable entry )*`, where a separator is one or more line breaks.
+	*/
+	#parseBareObject() {
+		const object = {};
+		const start = this.#index;
+
+		try {
+			this.#parseEntry(object, 1);
+		} catch (error) {
+			if (error instanceof ParseError) {
+				this.#diagnoseBareValue(start);
+			}
+
+			throw error;
+		}
+
+		for (;;) {
+			const sawLineBreak = this.#skipTrivia();
+
+			if (this.#isAtEnd()) {
+				return object;
+			}
+
+			if (!sawLineBreak) {
+				if (this.#code() === COMMA) {
+					this.#fail('Top-level entries are separated by line breaks, not commas. Use braces for a one-line object');
+				}
+
+				this.#fail(`Expected a line break before the next entry, but found ${this.#describeHere()}`);
+			}
+
+			this.#parseEntry(object, 1);
+		}
+	}
+
+	/*
+	A whole document that is one scalar, such as `5` or an instant, fails as an entry. That failure is reported as what it is.
+	*/
+	#diagnoseBareValue(start) {
+		this.#index = start;
+		let isBareValue = false;
+
+		try {
+			this.#parseValue(1);
+			this.#skipTrivia();
+			isBareValue = this.#isAtEnd();
+		} catch {
+			// Not a bare value either, so the original error stands.
+		}
+
+		if (isBareValue) {
+			this.#fail('A bare value is not a document. A document is an object or an array, so write it as `key: value` or `[value]`', start);
+		}
+	}
+
+	/*
+	Skips spaces, tabs, line breaks, and comments, and reports whether a line break was crossed. A line break inside a block comment does not count.
+	*/
+	#skipTrivia() {
+		const source = this.#source;
+		let hasCrossedLineBreak = false;
+
+		for (;;) {
+			switch (source.charCodeAt(this.#index)) {
+				case SPACE:
+				case TAB: {
+					this.#index++;
+					break;
+				}
+
+				case LF: {
+					hasCrossedLineBreak = true;
+					this.#index++;
+					break;
+				}
+
+				case HASH: {
+					const end = source.indexOf('\n', this.#index);
+					this.#index = end === -1 ? source.length : end;
+					break;
+				}
+
+				case SLASH: {
+					if (source.charCodeAt(this.#index + 1) !== ASTERISK) {
+						return hasCrossedLineBreak;
+					}
+
+					this.#skipBlockComment();
+					break;
+				}
+
+				default: {
+					return hasCrossedLineBreak;
+				}
+			}
+		}
+	}
+
+	#skipBlockComment() {
+		const source = this.#source;
+		const start = this.#index;
+		const end = source.indexOf('*/', start + 2);
+
+		if (end === -1) {
+			this.#fail('Unterminated block comment', start);
+		}
+
+		const nested = source.indexOf('/*', start + 2);
+
+		// The body may not contain `/*`. An opening that overlaps the closing `*/`, as in `/*/`, is not inside the body.
+		if (nested !== -1 && nested + 2 <= end) {
+			this.#fail('Block comments cannot be nested, and their body may not contain "/*"', nested);
+		}
+
+		this.#index = end + 2;
+	}
+
+	/*
+	Consumes `/-` and the spaces and tabs after it, and reports whether it was there.
+	*/
+	#parseRemoval() {
+		if (this.#code() !== SLASH || this.#code(this.#index + 1) !== DASH) {
+			return false;
+		}
+
+		const start = this.#index;
+		this.#index += 2;
+
+		while (this.#code() === SPACE || this.#code() === TAB) {
+			this.#index++;
+		}
+
+		const code = this.#code();
+
+		if (this.#isAtEnd() || code === LF || code === HASH || (code === SLASH && this.#code(this.#index + 1) === ASTERISK) || code === COMMA || code === CLOSE_BRACE || code === CLOSE_BRACKET) {
+			this.#fail('"/-" must be followed by the element it removes, on the same line', start);
+		}
+
+		return true;
+	}
+
+	/*
+	`entry = key ":" ws value`, with an optional `/-` before it.
+	*/
+	#parseEntry(object, depth) {
+		const isRemoved = this.#parseRemoval();
+		const keyStart = this.#index;
+		const path = this.#parseKey();
+
+		if (depth + path.length - 1 > MAX_DEPTH) {
+			this.#fail(`The document is nested more than ${MAX_DEPTH} levels deep`, keyStart);
+		}
+
+		const code = this.#code();
+
+		if (code !== COLON) {
+			this.#failMissingColon(keyStart);
+		}
+
+		this.#index++;
+		this.#skipTrivia();
+		const value = this.#parseValue(depth + path.length);
+
+		if (!isRemoved) {
+			this.#assign(object, path, value, keyStart);
+		}
+	}
+
+	#failMissingColon(keyStart) {
+		const source = this.#source;
+		let next = this.#index;
+
+		while (source.charCodeAt(next) === SPACE || source.charCodeAt(next) === TAB) {
+			next++;
+		}
+
+		const nextCode = source.charCodeAt(next);
+
+		if (next > this.#index && nextCode === COLON) {
+			this.#fail('Whitespace is not allowed between a key and its ":"');
+		}
+
+		const colon = source.indexOf(':', next);
+
+		// A key with a space in it, such as `the name: 1`. The hint is only given for plain words, because quoting a dotted or quoted key would change what it means.
+		if (next > this.#index && colon !== -1 && colon < findLineEnd(source, next) && nextCode < 128 && bareKeyCharacters[nextCode] === 1) {
+			const key = source.slice(keyStart, colon).trimEnd();
+
+			if (isWordsWithSpaces(key)) {
+				this.#fail(`A bare key cannot contain spaces. Quote it, as in '${abbreviate(key)}'`, keyStart);
+			}
+		}
+
+		if (this.#isAtEnd() || this.#code() === LF) {
+			this.#fail('Expected ":" after the key');
+		}
+
+		// A character directly after the key is most likely meant to be part of it.
+		const hint = next === this.#index ? '. A key that contains characters other than letters, digits, "_", and "-" must be quoted' : '';
+		this.#index = next;
+		this.#fail(`Expected ":" after the key, but found ${this.#describeHere()}${hint}`);
+	}
+
+	#parseKey() {
+		const path = [this.#parseKeySegment()];
+
+		while (this.#code() === DOT) {
+			this.#index++;
+			path.push(this.#parseKeySegment(true));
+		}
+
+		return path;
+	}
+
+	#parseKeySegment(isAfterDot = false) {
+		const source = this.#source;
+		const start = this.#index;
+		const code = source.charCodeAt(start);
+
+		if (code === SINGLE_QUOTE || code === DOUBLE_QUOTE) {
+			if (source.charCodeAt(start + 1) === code && source.charCodeAt(start + 2) === code) {
+				this.#fail('A block string cannot be a key');
+			}
+
+			// A key is a string, so it may hold anything a string can, including a line feed written as an escape.
+			return code === SINGLE_QUOTE ? this.#parseLiteralString() : this.#parseEscapedString();
+		}
+
+		let end = start;
+
+		while (end < source.length && source.charCodeAt(end) < 128 && bareKeyCharacters[source.charCodeAt(end)] === 1) {
+			end++;
+		}
+
+		if (end === start) {
+			if (isAfterDot) {
+				this.#fail(this.#isAtEnd() ? 'Expected a key segment after "."' : `Expected a key segment after ".", but found ${this.#describeHere()}`);
+			}
+
+			this.#fail(this.#isAtEnd() ? 'Expected a key' : `Expected a key, but found ${this.#describeHere()}`);
+		}
+
+		this.#index = end;
+		return source.slice(start, end);
+	}
+
+	#assign(object, path, value, keyStart) {
+		let target = object;
+		const lastIndex = path.length - 1;
+
+		for (let index = 0; index < lastIndex; index++) {
+			const key = path[index];
+
+			if (!Object.hasOwn(target, key)) {
+				const child = {};
+				this.#dottedObjects.add(child);
+				defineMember(target, key, child);
+				target = child;
+				continue;
+			}
+
+			const existing = target[key];
+
+			if (!this.#dottedObjects.has(existing)) {
+				const prefix = formatPath(path.slice(0, index + 1));
+				const what = describeValue(existing);
+				const reason = what === 'an object' ? 'an object written with braces, which is closed' : what;
+				this.#fail(`Cannot set ${formatPath(path)}, because ${prefix} is already ${reason} and a dotted key cannot extend it`, keyStart);
+			}
+
+			target = existing;
+		}
+
+		const key = path[lastIndex];
+
+		if (Object.hasOwn(target, key)) {
+			if (this.#dottedObjects.has(target[key])) {
+				this.#fail(`Cannot set ${formatPath(path)}: it is already an object built by dotted keys`, keyStart);
+			}
+
+			this.#fail(`Duplicate key ${formatPath(path)}`, keyStart);
+		}
+
+		defineMember(target, key, value);
+	}
+
+	#parseObject(depth) {
+		if (depth > MAX_DEPTH) {
+			this.#fail(`The document is nested more than ${MAX_DEPTH} levels deep`);
+		}
+
+		const start = this.#index;
+		const object = {};
+		this.#index++;
+		this.#skipTrivia();
+
+		for (;;) {
+			const code = this.#code();
+
+			if (code === CLOSE_BRACE) {
+				this.#index++;
+				return object;
+			}
+
+			if (this.#isAtEnd()) {
+				this.#fail('Unterminated object: expected "}"', start);
+			}
+
+			this.#parseEntry(object, depth);
+			this.#skipTrivia();
+
+			if (this.#code() === COMMA) {
+				this.#index++;
+				this.#skipTrivia();
+			} else if (this.#code() !== CLOSE_BRACE) {
+				this.#fail(this.#isAtEnd() ? 'Unterminated object: expected "}"' : `Expected "," or "}" after an object member, but found ${this.#describeHere()}`, this.#isAtEnd() ? start : this.#index);
+			}
+		}
+	}
+
+	#parseArray(depth) {
+		if (depth > MAX_DEPTH) {
+			this.#fail(`The document is nested more than ${MAX_DEPTH} levels deep`);
+		}
+
+		const start = this.#index;
+		const array = [];
+		this.#index++;
+		this.#skipTrivia();
+
+		for (;;) {
+			const code = this.#code();
+
+			if (code === CLOSE_BRACKET) {
+				this.#index++;
+				return array;
+			}
+
+			if (this.#isAtEnd()) {
+				this.#fail('Unterminated array: expected "]"', start);
+			}
+
+			const isRemoved = this.#parseRemoval();
+			const value = this.#parseValue(depth + 1);
+
+			if (!isRemoved) {
+				array.push(value);
+			}
+
+			this.#skipTrivia();
+
+			if (this.#code() === COMMA) {
+				this.#index++;
+				this.#skipTrivia();
+			} else if (this.#code() !== CLOSE_BRACKET) {
+				this.#fail(this.#isAtEnd() ? 'Unterminated array: expected "]"' : `Expected "," or "]" after an array item, but found ${this.#describeHere()}`, this.#isAtEnd() ? start : this.#index);
+			}
+		}
+	}
+
+	#parseValue(depth) {
+		const code = this.#code();
+
+		if (code === OPEN_BRACE) {
+			return this.#parseObject(depth);
+		}
+
+		if (code === OPEN_BRACKET) {
+			return this.#parseArray(depth);
+		}
+
+		let value;
+
+		if (code === SINGLE_QUOTE || code === DOUBLE_QUOTE) {
+			value = this.#parseString();
+		} else if (code === 0x74 /* t */ && this.#isKeyword('true')) {
+			value = true;
+		} else if (code === 0x66 /* f */ && this.#isKeyword('false')) {
+			value = false;
+		} else if (code === 0x6E /* n */ && this.#isKeyword('null')) {
+			value = null;
+		} else if (code === 0x69 /* i */ && this.#isKeyword('infinity')) {
+			value = Infinity;
+		} else if (code === DASH && this.#isKeyword('-infinity')) {
+			value = Number.NEGATIVE_INFINITY;
+		} else if ((code >= 0x30 && code <= 0x39) || code === DASH) {
+			value = this.#parseNumberOrInstant();
+		} else {
+			this.#failUnexpectedValue();
+		}
+
+		const next = this.#code();
+
+		if (!this.#isAtEnd() && (next >= 128 || valueEndCharacters[next] !== 1)) {
+			this.#fail(`Unexpected ${this.#describeHere()} after a value`);
+		}
+
+		return value;
+	}
+
+	#isKeyword(word) {
+		if (!this.#source.startsWith(word, this.#index)) {
+			return false;
+		}
+
+		const next = this.#code(this.#index + word.length);
+
+		// A longer word, such as `nullable`, is not the keyword.
+		if (next < 128 && bareKeyCharacters[next] === 1) {
+			return false;
+		}
+
+		this.#index += word.length;
+		return true;
+	}
+
+	#failUnexpectedValue() {
+		if (this.#isAtEnd()) {
+			this.#fail('Expected a value, but reached the end of the document');
+		}
+
+		const code = this.#code();
+
+		if (code === 0x2B /* + */) {
+			this.#fail('A "+" sign is not allowed. A number without a sign is positive');
+		}
+
+		if (code === DOT) {
+			this.#fail('A number cannot begin with "."; write a digit before it, as in 0.5');
+		}
+
+		let wordEnd = this.#index;
+
+		while (wordEnd < this.#source.length && this.#code(wordEnd) < 128 && bareKeyCharacters[this.#code(wordEnd)] === 1) {
+			wordEnd++;
+		}
+
+		if (wordEnd > this.#index) {
+			const word = this.#source.slice(this.#index, wordEnd);
+
+			// An entry whose value was left out, as in `a:` followed by `b: 1` on the next line, reads the next key as the value.
+			if (this.#code(wordEnd) === COLON) {
+				this.#fail(`Expected a value, but found the key ${abbreviate(word)}`);
+			}
+
+			this.#fail(describeUnknownWord(word));
+		}
+
+		this.#fail(`Expected a value, but found ${this.#describeHere()}`);
+	}
+
+	#describeHere() {
+		if (this.#isAtEnd()) {
+			return 'the end of the document';
+		}
+
+		const code = this.#source.codePointAt(this.#index);
+
+		return code === LF ? 'a line break' : describeCharacter(code);
+	}
+
+	#parseString() {
+		const source = this.#source;
+		const code = this.#code();
+
+		if (source.charCodeAt(this.#index + 1) === code && source.charCodeAt(this.#index + 2) === code) {
+			return this.#parseBlockString(code);
+		}
+
+		return code === SINGLE_QUOTE ? this.#parseLiteralString() : this.#parseEscapedString();
+	}
+
+	/*
+	`'...'` has no escapes, so its value is the source text between the quotes.
+	*/
+	#parseLiteralString() {
+		const source = this.#source;
+		const start = this.#index;
+		// Stops at the first quote or line break, so that a one-line document with many strings stays linear.
+		LITERAL_STRING_END.lastIndex = start + 1;
+		const match = LITERAL_STRING_END.exec(source);
+		const end = match?.index;
+
+		if (match === null || source.charCodeAt(end) === LF) {
+			this.#fail('Unterminated string. A \'...\' string must end on the line it starts on; use a block string (\'\'\') for multiple lines', start);
+		}
+
+		this.#index = end + 1;
+		return source.slice(start + 1, end);
+	}
+
+	#parseEscapedString() {
+		const source = this.#source;
+		const start = this.#index;
+		let chunkStart = start + 1;
+		let value = '';
+
+		for (;;) {
+			ESCAPED_STRING_SPECIAL.lastIndex = chunkStart;
+			const match = ESCAPED_STRING_SPECIAL.exec(source);
+
+			if (match === null || match[0] === '\n') {
+				this.#fail('Unterminated string. A "..." string must end on the line it starts on; use a block string (""") for multiple lines', start);
+			}
+
+			value += source.slice(chunkStart, match.index);
+
+			if (match[0] === '"') {
+				this.#index = match.index + 1;
+				return value;
+			}
+
+			const {text, end} = this.#parseEscape(match.index);
+			value += text;
+			chunkStart = end;
+		}
+	}
+
+	/*
+	Decodes the escape at `offset`, which is a backslash.
+	*/
+	#parseEscape(offset) {
+		const source = this.#source;
+		const character = source[offset + 1];
+		if (Object.hasOwn(SIMPLE_ESCAPES, character)) {
+			return {text: SIMPLE_ESCAPES[character], end: offset + 2};
+		}
+
+		if (character === 'u') {
+			UNICODE_ESCAPE.lastIndex = offset + 1;
+			const match = UNICODE_ESCAPE.exec(source);
+
+			if (match === null) {
+				this.#fail(describeBadUnicodeEscape(source, offset + 1), offset);
+			}
+
+			const {hex} = match.groups;
+
+			if (hex.length > 1 && hex.startsWith('0')) {
+				this.#fail(String.raw`A Unicode escape may not have leading zeros; write \u{${hex.replace(/^0+(?=.)/v, '')}}`, offset);
+			}
+
+			const codePoint = Number.parseInt(hex, 16);
+
+			if (codePoint === 0x0D) {
+				this.#fail(String.raw`A carriage return (U+000D) cannot be represented, so \u{d} is not allowed`, offset);
+			}
+
+			if (codePoint >= 0xD8_00 && codePoint <= 0xDF_FF) {
+				this.#fail(String.raw`\u{${hex}} is a surrogate, which is not a Unicode scalar value`, offset);
+			}
+
+			if (codePoint > 0x10_FF_FF) {
+				this.#fail(String.raw`\u{${hex}} is above U+10FFFF, the largest Unicode scalar value`, offset);
+			}
+
+			return {text: String.fromCodePoint(codePoint), end: offset + 1 + match[0].length};
+		}
+
+		if (character === 'r') {
+			this.#fail(String.raw`There is no \r escape, because a carriage return cannot be represented`, offset);
+		}
+
+		if (character === '\'') {
+			this.#fail('A \' needs no escape inside "..."', offset);
+		}
+
+		if (character === undefined || character === '\n') {
+			this.#fail(String.raw`A backslash must be followed by an escape character. Use \\ for a literal backslash, or a '...' string`, offset);
+		}
+
+		this.#fail(`Unknown escape "\\${String.fromCodePoint(source.codePointAt(offset + 1))}". The escapes are \\\\, \\", \\n, \\t, and \\u{…}; use a '...' string for literal backslashes`, offset);
+	}
+
+	/*
+	A block string opens with a run of three or more quotes and a line break, and closes at the first line whose first non-whitespace content is a run of exactly that many quotes. The closing line's indentation is removed from every content line, except a blank one, which holds only spaces and tabs and becomes an empty line.
+	*/
+	#parseBlockString(quote) {
+		const source = this.#source;
+		const start = this.#index;
+		let delimiterLength = 0;
+
+		while (source.charCodeAt(start + delimiterLength) === quote) {
+			delimiterLength++;
+		}
+
+		this.#index = start + delimiterLength;
+
+		if (this.#isAtEnd()) {
+			this.#fail('Unterminated block string', start);
+		}
+
+		// As in Swift, the opening delimiter is followed directly by a line break, not even by trailing whitespace.
+		if (this.#code() !== LF) {
+			this.#fail('A block string\'s opening delimiter must be followed directly by a line break, and its content starts on the next line');
+		}
+
+		this.#index++;
+
+		// Each content line as a pair of source offsets.
+		const lines = [];
+		let indentation;
+
+		for (;;) {
+			// Past the last line, either because the source ended with a line break or because the last line was content.
+			if (this.#index >= source.length) {
+				this.#fail('Unterminated block string', start);
+			}
+
+			const lineStart = this.#index;
+			let lineEnd = source.indexOf('\n', lineStart);
+
+			if (lineEnd === -1) {
+				lineEnd = source.length;
+			}
+
+			let contentStart = lineStart;
+
+			while (contentStart < lineEnd && (source.charCodeAt(contentStart) === SPACE || source.charCodeAt(contentStart) === TAB)) {
+				contentStart++;
+			}
+
+			let runLength = 0;
+
+			while (source.charCodeAt(contentStart + runLength) === quote) {
+				runLength++;
+			}
+
+			if (runLength === delimiterLength) {
+				indentation = source.slice(lineStart, contentStart);
+				this.#index = contentStart + delimiterLength;
+				break;
+			}
+
+			lines.push(lineStart, lineEnd);
+			this.#index = lineEnd + 1;
+		}
+
+		const contents = [];
+
+		for (let index = 0; index < lines.length; index += 2) {
+			const lineStart = lines[index];
+			const line = source.slice(lineStart, lines[index + 1]);
+
+			// A blank line, which is empty or holds only spaces and tabs, may leave out the indentation, and it becomes an empty line. Swift is stricter here: there only a completely empty line may leave it out.
+			if (BLANK_LINE.test(line)) {
+				contents.push({text: '', offset: lineStart});
+			} else if (line.startsWith(indentation)) {
+				contents.push({text: line.slice(indentation.length), offset: lineStart + indentation.length});
+			} else {
+				this.#fail('This line does not start with the indentation of its block string\'s closing delimiter. Every line except a blank one must start with exactly the same spaces and tabs', lineStart);
+			}
+		}
+
+		// Blank lines directly after the opening delimiter and directly before the closing one are not content. Every blank line is empty by now.
+		let first = 0;
+		let last = contents.length;
+
+		while (first < last && contents[first].text === '') {
+			first++;
+		}
+
+		while (last > first && contents[last - 1].text === '') {
+			last--;
+		}
+
+		const kept = contents.slice(first, last);
+
+		return quote === SINGLE_QUOTE ? kept.map(line => line.text).join('\n') : kept.map(line => this.#unescapeLine(line.text, line.offset)).join('\n');
+	}
+
+	#unescapeLine(text, offset) {
+		let value = '';
+		let chunkStart = 0;
+
+		for (let index = text.indexOf('\\'); index !== -1; index = text.indexOf('\\', chunkStart)) {
+			value += text.slice(chunkStart, index);
+			const escape = this.#parseEscape(offset + index);
+			value += escape.text;
+			chunkStart = escape.end - offset;
+		}
+
+		return value + text.slice(chunkStart);
+	}
+
+	#parseNumberOrInstant() {
+		const plain = this.#parsePlainNumber();
+
+		if (plain !== undefined) {
+			return plain;
+		}
+
+		const source = this.#source;
+		const start = this.#index;
+		let end = start + 1;
+
+		while (end < source.length && source.charCodeAt(end) < 128 && numberCharacters[source.charCodeAt(end)] === 1) {
+			end++;
+		}
+
+		const text = source.slice(start, end);
+		this.#index = end;
+
+		if (INSTANT_PREFIX.test(text)) {
+			return this.#parseInstant(text, start);
+		}
+
+		const kind = classifyNumber(text);
+
+		if (kind === undefined && isDurationLike(text)) {
+			return this.#parseDuration(text, start);
+		}
+
+		switch (kind) {
+			case 'decimal':
+			case 'radix': {
+				if (text === '-0') {
+					this.#fail('"-0" is not allowed, because zero has one spelling: 0', start);
+				}
+
+				return this.#integer(text.replaceAll('_', ''), text, start);
+			}
+
+			case 'float': {
+				const value = Number(text.replaceAll('_', ''));
+
+				if (!Number.isFinite(value)) {
+					this.#fail(`${abbreviate(text)} is too large to be a finite float. Use infinity if you mean it`, start);
+				}
+
+				// Negative zero is the same value as zero.
+				return value === 0 ? 0 : value;
+			}
+
+			default: {
+				break;
+			}
+		}
+
+		this.#fail(describeBadNumber(text), start);
+	}
+
+	/*
+	The common case, a short decimal int or float such as `8080`, `-3`, or `30.5`, without the general path's maximal-run scan and classification. Anything else, including every error, returns `undefined` and is left to the general path.
+	*/
+	#parsePlainNumber() {
+		const source = this.#source;
+		const start = this.#index;
+		let index = source.charCodeAt(start) === DASH ? start + 1 : start;
+		const integerStart = index;
+
+		while (isDigit(source.charCodeAt(index))) {
+			index++;
+		}
+
+		const integerLength = index - integerStart;
+
+		// No digits, or a leading zero, which is either `0` alone or an error.
+		if (integerLength === 0 || (integerLength > 1 && source.charCodeAt(integerStart) === 0x30)) {
+			return;
+		}
+
+		let isFloat = false;
+
+		if (source.charCodeAt(index) === DOT) {
+			const fractionStart = index + 1;
+			index = fractionStart;
+
+			while (isDigit(source.charCodeAt(index))) {
+				index++;
+			}
+
+			if (index === fractionStart) {
+				return;
+			}
+
+			isFloat = true;
+		}
+
+		const next = source.charCodeAt(index);
+
+		// At most 15 digits, so an int is exact as a number. A character that may continue a number, such as `e`, `_`, or `-`, needs the general path.
+		if (index - integerStart > 15 || (index < source.length && (next >= 128 || valueEndCharacters[next] !== 1))) {
+			return;
+		}
+
+		const value = Number(source.slice(start, index));
+
+		if (isFloat) {
+			this.#index = index;
+
+			// Negative zero is the same value as zero.
+			return value === 0 ? 0 : value;
+		}
+
+		// `-0` is an error, which the general path reports.
+		if (value === 0 && index - start > 1) {
+			return;
+		}
+
+		this.#index = index;
+		return this.#integers === 'bigint' ? BigInt(value) : value;
+	}
+
+	/*
+	`digits` is the int without underscores. More than 64 significant digits is out of range in any radix, which is decided before `BigInt` spends time on a huge digit string.
+	*/
+	#integer(digits, text, start) {
+		const isRadix = digits.length > 1 && digits.charCodeAt(1) > 0x39;
+		let significant = digits.charCodeAt(0) === DASH ? 1 : 0;
+
+		if (isRadix) {
+			significant = 2;
+
+			while (digits.charCodeAt(significant) === 0x30) {
+				significant++;
+			}
+		}
+
+		const value = digits.length - significant > 64 ? undefined : BigInt(isRadix ? `${digits.slice(0, 2)}${digits.slice(significant) || '0'}` : digits);
+
+		if (value === undefined || value < INT64_MIN || value > INT64_MAX) {
+			this.#fail(`The integer ${abbreviate(text)} is outside the 64-bit range (-9223372036854775808 to 9223372036854775807)`, start);
+		}
+
+		if (this.#integers === 'bigint') {
+			return value;
+		}
+
+		if (value < Number.MIN_SAFE_INTEGER || value > Number.MAX_SAFE_INTEGER) {
+			this.#fail(`The integer ${abbreviate(text)} cannot be represented exactly as a JavaScript number. Remove the \`integers: 'number'\` option to get a BigInt`, start);
+		}
+
+		return Number(value);
+	}
+
+	#parseInstant(text, start) {
+		const match = text.length > MAX_DIAGNOSED_LENGTH ? null : INSTANT.exec(text);
+
+		if (match === null) {
+			this.#fail(describeBadInstant(text), start);
+		}
+
+		const {year, month, day, hour, minute, second, fraction, offset, offsetHour, offsetMinute} = match.groups;
+		const check = (isValid, reason) => {
+			if (!isValid) {
+				this.#fail(`Invalid instant ${abbreviate(text)}: ${reason}`, start);
+			}
+		};
+
+		check(fraction === undefined || fraction.length <= 9, 'a fractional second has at most nine digits');
+		check(year !== '0000', 'the year must be 0001 to 9999');
+		check(month >= '01' && month <= '12', 'the month must be 01 to 12');
+		const lastDay = daysInMonth(Number(year), Number(month));
+		check(day >= '01' && Number(day) <= lastDay, `the day must be 01 to ${lastDay} in that month`);
+		check(hour <= '23', 'the hour must be 00 to 23');
+		check(minute <= '59', 'the minute must be 00 to 59');
+		check(second <= '59', 'the second must be 00 to 59, and a leap second is not representable');
+
+		if (offset !== 'Z') {
+			check(offsetHour <= '23', 'the offset hour must be 00 to 23');
+			check(offsetMinute <= '59', 'the offset minute must be 00 to 59');
+			check(offset !== '-00:00', '-00:00 means "offset unknown" in RFC 3339, which is not representable; use Z or +00:00');
+		}
+
+		const instant = Temporal.Instant.from(text);
+		const nanoseconds = instant.epochNanoseconds;
+		check(nanoseconds >= MIN_INSTANT && nanoseconds <= MAX_INSTANT, 'in UTC it falls outside the years 0001 to 9999');
+		return instant;
+	}
+
+	/*
+	A scan of the parts in order, so that each error names the part it is about.
+	*/
+	#parseDuration(text, start) {
+		const fail = reason => {
+			this.#fail(`Invalid duration ${abbreviate(text)}: ${reason}`, start);
+		};
+
+		const isNegative = text.charCodeAt(0) === DASH;
+		let index = isNegative ? 1 : 0;
+		let previousRank = -1;
+		let total = 0n;
+		// The fraction of the last part, and that part's unit size. Only the last part may have one, so the value checks wait until every part is read.
+		let fraction = '';
+		let size = 0n;
+
+		while (index < text.length) {
+			const digitsEnd = skipIntegerPart(text, index);
+			const next = text.charCodeAt(digitsEnd);
+
+			if (digitsEnd === index) {
+				const code = text.charCodeAt(index);
+
+				if (code === DASH && isDigit(text.charCodeAt(index + 1))) {
+					fail('only the whole duration takes a sign, as in -1h30m');
+				}
+
+				fail(code === 0x2B /* + */ ? 'a "+" sign is not allowed' : `expected a number at "${abbreviate(text.slice(index), 10)}"`);
+			}
+
+			if (text.charCodeAt(index) === 0x30 && (isDigit(next) || next === 0x5F /* _ */)) {
+				fail('leading zeros are not allowed');
+			}
+
+			if (next === 0x5F /* _ */) {
+				fail('an underscore must be between two digits');
+			}
+
+			fraction = '';
+			let unitStart = digitsEnd;
+
+			if (next === DOT) {
+				unitStart = skipDigits(text, digitsEnd + 1, isDigit);
+
+				if (unitStart === digitsEnd + 1) {
+					fail('a "." must be followed by a digit');
+				}
+
+				if (text.charCodeAt(unitStart) === 0x5F /* _ */) {
+					fail('an underscore must be between two digits');
+				}
+
+				// Trailing zeros change nothing, and leaving them out keeps the arithmetic small however many there are.
+				fraction = trimTrailingZeros(text.slice(digitsEnd + 1, unitStart).replaceAll('_', ''));
+			}
+
+			let unitEnd = unitStart;
+
+			while (isLetter(text.charCodeAt(unitEnd))) {
+				unitEnd++;
+			}
+
+			const unit = text.slice(unitStart, unitEnd);
+			const rank = DURATION_UNIT_NAMES.indexOf(unit);
+
+			if (rank === -1) {
+				fail(describeBadDurationUnit(unit));
+			}
+
+			if (rank <= previousRank) {
+				fail('the units are in the order h, m, s, ms, us, ns, and each appears at most once');
+			}
+
+			if (next === DOT && isDigit(text.charCodeAt(unitEnd))) {
+				fail('only the last part may have a fraction');
+			}
+
+			size = DURATION_UNITS.get(unit);
+			const digits = text.slice(index, digitsEnd).replaceAll('_', '');
+			// More than 19 digits is out of range in any unit, which is decided before `BigInt` spends time on a huge digit string.
+			total += digits.length > 19 ? INT64_MAX * 2n : BigInt(digits) * size;
+			index = unitEnd;
+			previousRank = rank;
+		}
+
+		// More than 13 fraction digits without a trailing zero is finer than a nanosecond in any unit, which is decided before `BigInt` spends time on a huge digit string.
+		if (fraction.length > 13) {
+			fail('it is not a whole number of nanoseconds');
+		}
+
+		if (fraction !== '') {
+			const scale = 10n ** BigInt(fraction.length);
+			const fractionNanoseconds = BigInt(fraction) * size;
+
+			if (fractionNanoseconds % scale !== 0n) {
+				fail('it is not a whole number of nanoseconds');
+			}
+
+			total += fractionNanoseconds / scale;
+		}
+
+		if (isNegative && total === 0n) {
+			fail('"-" is not allowed before zero, because zero has one spelling: 0s');
+		}
+
+		if (total > (isNegative ? -INT64_MIN : INT64_MAX)) {
+			fail('it is outside the 64-bit range of nanoseconds, about 292 years either way');
+		}
+
+		return createDuration(isNegative ? -total : total);
+	}
+}
+
+/*
+Whether `text` is a decimal int, a radix int, or a float, following the grammar. A run of digits may have single underscores between digits.
+*/
+function classifyNumber(text) {
+	const radix = text.charCodeAt(0) === 0x30 ? RADIX_DIGIT[text[1]] : undefined;
+
+	if (radix !== undefined) {
+		const end = skipDigits(text, 2, radix);
+		return end > 2 && end === text.length ? 'radix' : undefined;
+	}
+
+	let index = text.charCodeAt(0) === DASH ? 1 : 0;
+
+	// The integer part is `0` or has no leading zero.
+	const integerEnd = skipIntegerPart(text, index);
+
+	if (integerEnd === index) {
+		return undefined;
+	}
+
+	index = integerEnd;
+
+	let kind = 'decimal';
+
+	if (text.charCodeAt(index) === DOT) {
+		const end = skipDigits(text, index + 1, isDigit);
+
+		if (end === index + 1) {
+			return undefined;
+		}
+
+		index = end;
+		kind = 'float';
+	}
+
+	if (text.charCodeAt(index) === 0x65 /* e */) {
+		const isNegative = text.charCodeAt(index + 1) === DASH;
+		const exponentStart = index + (isNegative ? 2 : 1);
+		// The exponent follows the same leading-zero rule as the integer part, and its zero has one spelling, `e0`, so `e-0` is not an exponent.
+		const end = isNegative && text.charCodeAt(exponentStart) === 0x30 ? exponentStart : skipIntegerPart(text, exponentStart);
+
+		if (end === exponentStart) {
+			return undefined;
+		}
+
+		index = end;
+		kind = 'float';
+	}
+
+	return index === text.length ? kind : undefined;
+}
+
+/*
+Returns the index after a run of digits that may have single underscores between them, or `index` when there is no digit there.
+*/
+function skipDigits(text, index, isValidDigit) {
+	if (!isValidDigit(text.charCodeAt(index))) {
+		return index;
+	}
+
+	index++;
+
+	for (;;) {
+		const code = text.charCodeAt(index);
+
+		if (isValidDigit(code)) {
+			index++;
+		} else if (code === 0x5F /* _ */ && isValidDigit(text.charCodeAt(index + 1))) {
+			index += 2;
+		} else {
+			return index;
+		}
+	}
+}
+
+/*
+Returns the index after an integer part, which is `0` or digits without a leading zero, or `index` when there is none. Anything after a leading `0`, such as the `5` in `05`, is left for the caller to reject.
+*/
+function skipIntegerPart(text, index) {
+	return text.charCodeAt(index) === 0x30 ? index + 1 : skipDigits(text, index, isDigit);
+}
+
+function isDigit(code) {
+	return code >= 0x30 && code <= 0x39;
+}
+
+function isLetter(code) {
+	return (code >= 0x41 && code <= 0x5A) || (code >= 0x61 && code <= 0x7A);
+}
+
+/*
+Whether a token that is not a number or an instant was meant as a duration: its first letter could begin a unit, or a day or a week. A radix prefix, an exponent, and other letters, such as the `T` in `20260919T140000Z` or the `x` in `1.5x`, are left to the number errors.
+*/
+function isDurationLike(text) {
+	const start = text.charCodeAt(0) === DASH ? 1 : 0;
+
+	if (!isDigit(text.charCodeAt(start))) {
+		return false;
+	}
+
+	// A scan rather than a regular expression, because a fraction may have any number of trailing zeros, so the first letter can be millions of characters in.
+	let index = start;
+
+	while (isDigit(text.charCodeAt(index)) || text.charCodeAt(index) === 0x5F) {
+		index++;
+	}
+
+	if (text.charCodeAt(index) === DOT) {
+		index++;
+
+		while (isDigit(text.charCodeAt(index)) || text.charCodeAt(index) === 0x5F) {
+			index++;
+		}
+	}
+
+	return /^[dhmnsuw]$/iv.test(text.charAt(index));
+}
+
+function describeBadDurationUnit(unit) {
+	if (unit === '') {
+		return 'every number needs a unit: h, m, s, ms, us, or ns';
+	}
+
+	if (/^d(?:ays?)?$/v.test(unit)) {
+		return 'there is no day unit, because a day is not a fixed length. Write 24h for a fixed 24 hours';
+	}
+
+	if (/^w(?:eeks?)?$/v.test(unit)) {
+		return 'there is no week unit, because a day is not a fixed length. Write 168h for a fixed 168 hours';
+	}
+
+	if (DURATION_UNITS.has(unit.toLowerCase())) {
+		return `the units are lowercase: ${unit.toLowerCase()}`;
+	}
+
+	return `"${abbreviate(unit, 10)}" is not a unit. The units are h, m, s, ms, us, and ns, and a string must be quoted`;
+}
+
+function isWordsWithSpaces(text) {
+	for (let index = 0; index < text.length; index++) {
+		const code = text.charCodeAt(index);
+
+		if (code !== SPACE && code !== TAB && (code >= 128 || bareKeyCharacters[code] !== 1)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function findLineEnd(source, offset) {
+	const end = source.indexOf('\n', offset);
+	return end === -1 ? source.length : end;
+}
+
+function daysInMonth(year, month) {
+	if (month === 2) {
+		const isLeapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+		return isLeapYear ? 29 : 28;
+	}
+
+	return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+
+function describeUnknownWord(word) {
+	const lowercase = word.toLowerCase();
+
+	if (['true', 'false', 'yes', 'no', 'on', 'off'].includes(lowercase)) {
+		return `"${word}" is not a value. Booleans are written true and false, in lowercase`;
+	}
+
+	if (['null', 'nil', 'none', 'undefined'].includes(lowercase)) {
+		return `"${word}" is not a value. Null is written null, in lowercase`;
+	}
+
+	if (lowercase === 'nan') {
+		return 'NaN is not representable. Use null for a missing value';
+	}
+
+	return ['inf', 'infinity'].includes(lowercase) ? `"${word}" is not a value. Infinity is written infinity, in lowercase` : `Unexpected "${abbreviate(word)}". A string value must be quoted, as in '${abbreviate(word)}'`;
+}
+
+function describeBadUnicodeEscape(source, offset) {
+	const rest = source.slice(offset, offset + 12);
+
+	if (/^u[\dA-Fa-f]{4}/v.test(rest)) {
+		return `The four-digit \\${rest.slice(0, 5)} form is not an escape. Write \\u{${rest.slice(1, 5).toLowerCase().replace(/^0+(?=.)/v, '')}}`;
+	}
+
+	if (/^u\{[\dA-Fa-f]*[A-F]/v.test(rest)) {
+		return 'A Unicode escape uses lowercase hexadecimal digits';
+	}
+
+	if (/^u\{\}/v.test(rest)) {
+		return 'A Unicode escape needs one to six hexadecimal digits';
+	}
+
+	return /^u\{[\da-f]{7}/v.test(rest) ? 'A Unicode escape has at most six hexadecimal digits' : String.raw`A Unicode escape is written \u{…} with one to six lowercase hexadecimal digits`;
+}
+
+function describeBadNumber(fullText) {
+	const text = fullText.slice(0, MAX_DIAGNOSED_LENGTH);
+
+	if (text.includes('+')) {
+		return 'A "+" sign is not allowed in a number, including in an exponent';
+	}
+
+	if (/^-?0[BOX]/v.test(text)) {
+		return 'A number prefix is lowercase: 0x, 0o, or 0b';
+	}
+
+	const radixMatch = /^(?<sign>-?)0(?<radix>[box])(?<digits>.*)$/v.exec(text);
+
+	if (radixMatch !== null) {
+		const {sign, radix, digits} = radixMatch.groups;
+		const name = RADIX_NAME[radix];
+
+		if (sign === '-') {
+			return `${RADIX_ARTICLE[radix]} ${name} integer cannot have a sign, because it states a bit pattern rather than a quantity`;
+		}
+
+		if (digits === '') {
+			return `Expected ${name} digits after "0${radix}"`;
+		}
+
+		if (radix === 'x' && /[a-f]/v.test(digits) && !/[^\da-f_]/iv.test(digits)) {
+			return `Hexadecimal digits are uppercase: 0x${abbreviate(digits.toUpperCase())}`;
+		}
+
+		const validCharacter = {x: /[\dA-F_]/v, o: /[0-7_]/v, b: /[01_]/v}[radix];
+		const character = [...digits].find(character => !validCharacter.test(character));
+
+		return character === undefined ? 'An underscore in a number must be between two digits' : `Invalid ${name} digit "${character}"`;
+	}
+
+	if (/^-?\d[\d_]*E/v.test(text) || /^-?\d[\d_]*\.[\d_]+E/v.test(text)) {
+		return 'An exponent marker is a lowercase "e"';
+	}
+
+	if (/^-?[\d_]+\.(?:$|[^\d_])/v.test(text)) {
+		return 'A decimal point must be followed by a digit';
+	}
+
+	if (/^-\./v.test(text)) {
+		return 'A number cannot begin with "."; write a digit before it, as in -0.5';
+	}
+
+	if (/^-?0[\d_]/v.test(text)) {
+		return 'Leading zeros are not allowed in a decimal number';
+	}
+
+	if (/_(?:$|\D)|(?:^|\D)_/v.test(text)) {
+		return 'An underscore in a number must be between two digits';
+	}
+
+	if (/^-?\d[\d_]*(?:\.[\d_]+)?e-?0_?\d/v.test(text)) {
+		return 'Leading zeros are not allowed in an exponent';
+	}
+
+	if (/^-?\d[\d_]*(?:\.[\d_]+)?e-0$/v.test(text)) {
+		return '"e-0" is not allowed, because an exponent of zero has one spelling: e0';
+	}
+
+	if (/e-?$/v.test(text)) {
+		return 'Expected digits after the exponent marker "e"';
+	}
+
+	if (text.split('.').length > 2) {
+		return `Invalid number "${abbreviate(text)}". A value with several dots, such as a version number, must be quoted`;
+	}
+
+	if (/^-(?:\D|$)/v.test(text)) {
+		if (/^-nan/iv.test(text)) {
+			return 'NaN is not representable. Use null for a missing value';
+		}
+
+		return /^-inf/iv.test(text) ? `"${abbreviate(text)}" is not a value. Negative infinity is written -infinity` : 'Expected a digit or "infinity" after "-"';
+	}
+
+	return /[A-Za-z]/v.test(text) ? `Invalid number "${abbreviate(text)}". A string value must be quoted, as in '${abbreviate(text)}'` : `Invalid number "${abbreviate(text)}"`;
+}
+
+function describeBadInstant(text) {
+	if (text.length > MAX_DIAGNOSED_LENGTH) {
+		return `Invalid instant "${abbreviate(text)}". An instant is written as 2026-09-19T14:00:00Z, with an optional fraction of up to nine digits and an offset of Z or ±HH:MM`;
+	}
+
+	if (/^\d{4}-\d{2}-\d{2}$/v.test(text)) {
+		return `${text} is a date, not an instant. An instant needs a time and an offset, as in ${text}T00:00:00Z; use a string for a date`;
+	}
+
+	if (/^\d{4}-\d{2}-\d{2}t/v.test(text)) {
+		return 'The date and time separator in an instant is an uppercase "T"';
+	}
+
+	if (text.endsWith('z')) {
+		return 'The UTC offset in an instant is an uppercase "Z"';
+	}
+
+	if (/[+\-]\d{4}$/v.test(text)) {
+		return 'An instant\'s offset is written with a colon, as in +07:00';
+	}
+
+	return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/v.test(text) ? 'An instant needs an offset: Z or ±HH:MM' : `Invalid instant "${abbreviate(text)}". An instant is written as 2026-09-19T14:00:00Z, with an optional fraction of up to nine digits and an offset of Z or ±HH:MM`;
+}