@effected/toml 0.1.0

package/index.js

@@ -0,0 +1,10 @@
+import { TomlLocalDate, TomlLocalDateTime, TomlLocalTime, TomlOffsetDateTime } from "./TomlDateTime.js";
+import { TomlArray, TomlArrayTableHeader, TomlBoolean, TomlDateTimeLiteral, TomlExpression, TomlFloat, TomlInlineEntry, TomlInlineTable, TomlInteger, TomlKey, TomlKeyKind, TomlKeyValue, TomlString, TomlStringStyle, TomlTableHeader, TomlTrivia, TomlValueNode } from "./TomlNode.js";
+import { TomlDiagnostic, TomlErrorCode, TomlLexErrorCode, TomlParseErrorCode, TomlSemanticErrorCode, TomlStringifyErrorCode } from "./TomlDiagnostic.js";
+import { Toml, TomlParseError, TomlStringifyError, TomlStringifyOptions } from "./Toml.js";
+import { TomlDocument } from "./TomlDocument.js";
+import { TomlEdit, TomlRange } from "./TomlEdit.js";
+import { TomlFormat, TomlFormattingOptions, TomlModificationError } from "./TomlFormat.js";
+import { TomlVisitor, TomlVisitorEvent } from "./TomlVisitor.js";
+
+export { Toml, TomlArray, TomlArrayTableHeader, TomlBoolean, TomlDateTimeLiteral, TomlDiagnostic, TomlDocument, TomlEdit, TomlErrorCode, TomlExpression, TomlFloat, TomlFormat, TomlFormattingOptions, TomlInlineEntry, TomlInlineTable, TomlInteger, TomlKey, TomlKeyKind, TomlKeyValue, TomlLexErrorCode, TomlLocalDate, TomlLocalDateTime, TomlLocalTime, TomlModificationError, TomlOffsetDateTime, TomlParseError, TomlParseErrorCode, TomlRange, TomlSemanticErrorCode, TomlString, TomlStringStyle, TomlStringifyError, TomlStringifyErrorCode, TomlStringifyOptions, TomlTableHeader, TomlTrivia, TomlValueNode, TomlVisitor, TomlVisitorEvent };

package/internal/diagnostics.js

@@ -0,0 +1,53 @@
+//#region src/internal/diagnostics.ts
+const TOML_LEX_ERROR_CODES = [
+	"InvalidUtf8",
+	"UnterminatedString",
+	"InvalidEscape",
+	"InvalidUnicodeEscape",
+	"ControlCharacterInString",
+	"ControlCharacterInComment",
+	"InvalidCharacter",
+	"BareCarriageReturn"
+];
+const TOML_PARSE_ERROR_CODES = [
+	"ExpectedKey",
+	"ExpectedEquals",
+	"ExpectedValue",
+	"ExpectedNewline",
+	"ExpectedTableHeaderClose",
+	"UnterminatedArray",
+	"UnterminatedInlineTable",
+	"TrailingCommaInInlineTable",
+	"NewlineInInlineTable",
+	"InvalidValue",
+	"InvalidNumber",
+	"IntegerOutOfRange",
+	"InvalidDateTime",
+	"NestingDepthExceeded"
+];
+const TOML_SEMANTIC_ERROR_CODES = [
+	"DuplicateKey",
+	"TableRedefined",
+	"ArrayOfTablesConflict",
+	"DottedKeyConflict",
+	"InlineTableExtended"
+];
+const TOML_STRINGIFY_ERROR_CODES = [
+	"CircularReference",
+	"UnsupportedValue",
+	"IntegerOutOfRange",
+	"NestingDepthExceeded"
+];
+/** The engine's only throw carrier besides GuardExceeded. */
+var RawTomlError = class extends Error {
+	diagnostic;
+	_tag = "RawTomlError";
+	constructor(diagnostic) {
+		super(diagnostic.message);
+		this.diagnostic = diagnostic;
+	}
+};
+const isRawTomlError = (u) => u instanceof RawTomlError;
+
+//#endregion
+export { RawTomlError, TOML_LEX_ERROR_CODES, TOML_PARSE_ERROR_CODES, TOML_SEMANTIC_ERROR_CODES, TOML_STRINGIFY_ERROR_CODES, isRawTomlError };

package/internal/limits.js

@@ -0,0 +1,24 @@
+//#region src/internal/limits.ts
+/**
+* Raw guard-trip signal. The engine throws it; ONLY the public modules catch
+* it and materialize the typed error. It must never escape a public entry
+* point as a defect.
+*/
+var GuardExceeded = class extends Error {
+	reason;
+	limit;
+	actual;
+	offset;
+	_tag = "GuardExceeded";
+	constructor(reason, limit, actual, offset) {
+		super(`${reason}: limit ${limit}, actual ${actual}`);
+		this.reason = reason;
+		this.limit = limit;
+		this.actual = actual;
+		this.offset = offset;
+	}
+};
+const isGuardExceeded = (u) => u instanceof GuardExceeded;
+
+//#endregion
+export { GuardExceeded, isGuardExceeded };

package/internal/parser.js

@@ -0,0 +1,408 @@
+import { RawTomlError } from "./diagnostics.js";
+import { GuardExceeded } from "./limits.js";
+import { TomlLocalDate, TomlLocalDateTime, TomlLocalTime, TomlOffsetDateTime } from "../TomlDateTime.js";
+import { TomlArray, TomlArrayTableHeader, TomlBoolean, TomlDateTimeLiteral, TomlFloat, TomlInlineEntry, TomlInlineTable, TomlInteger, TomlKey, TomlKeyValue, TomlString, TomlTableHeader, TomlTrivia } from "../TomlNode.js";
+import { assertValidUnicode, classifyValueToken, scanBareKey, scanBasicString, scanComment, scanLiteralString, scanMultilineBasicString, scanMultilineLiteralString, scanNewline, scanValueToken, scanWhitespace, skipBom } from "./scanner.js";
+
+//#region src/internal/parser.ts
+const LF = 10;
+const CR = 13;
+const QUOTE = 34;
+const HASH = 35;
+const APOSTROPHE = 39;
+const COMMA = 44;
+const DOT = 46;
+const EQUALS = 61;
+const LEFT_BRACKET = 91;
+const RIGHT_BRACKET = 93;
+const LEFT_BRACE = 123;
+const RIGHT_BRACE = 125;
+const raise = (code, message, offset, length) => {
+	throw new RawTomlError({
+		code,
+		message,
+		offset,
+		length
+	});
+};
+/** Decoded trailing-comment text: the raw text after `#` with one leading space stripped. */
+const decodeComment = (raw) => raw.startsWith(" ") ? raw.slice(1) : raw;
+/** One simple key: bare, basic-quoted or literal-quoted. */
+const parseSimpleKey = (source, pos) => {
+	const code = source.charCodeAt(pos);
+	if (code === QUOTE) {
+		const scanned = scanBasicString(source, pos);
+		return {
+			node: new TomlKey({
+				value: scanned.value,
+				kind: "basic",
+				offset: pos,
+				length: scanned.end - pos
+			}),
+			end: scanned.end
+		};
+	}
+	if (code === APOSTROPHE) {
+		const scanned = scanLiteralString(source, pos);
+		return {
+			node: new TomlKey({
+				value: scanned.value,
+				kind: "literal",
+				offset: pos,
+				length: scanned.end - pos
+			}),
+			end: scanned.end
+		};
+	}
+	const bare = scanBareKey(source, pos);
+	if (bare.end === pos) return raise("ExpectedKey", "expected a key", pos, 1);
+	return {
+		node: new TomlKey({
+			value: bare.value,
+			kind: "bare",
+			offset: pos,
+			length: bare.end - pos
+		}),
+		end: bare.end
+	};
+};
+/** A dotted key path: `simple-key ( ws "." ws simple-key )*`. */
+const parseKeyPath = (source, pos) => {
+	const keys = [];
+	const first = parseSimpleKey(source, pos);
+	keys.push(first.node);
+	let i = first.end;
+	for (;;) {
+		const afterWs = scanWhitespace(source, i);
+		if (source.charCodeAt(afterWs) !== DOT) break;
+		const keyStart = scanWhitespace(source, afterWs + 1);
+		const next = parseSimpleKey(source, keyStart);
+		keys.push(next.node);
+		i = next.end;
+	}
+	return {
+		node: keys,
+		end: i
+	};
+};
+/** The end of an expression line: ws + optional comment + newline (or EOF), else ExpectedNewline. */
+const parseLineEnd = (source, pos) => {
+	let i = scanWhitespace(source, pos);
+	let comment;
+	if (source.charCodeAt(i) === HASH) {
+		const scanned = scanComment(source, i);
+		comment = decodeComment(scanned.value);
+		i = scanned.end;
+	}
+	if (i >= source.length) return {
+		...comment !== void 0 ? { comment } : {},
+		end: i
+	};
+	const after = scanNewline(source, i);
+	if (after === i) return raise("ExpectedNewline", "expected a newline after the expression", i, 1);
+	return {
+		...comment !== void 0 ? { comment } : {},
+		end: after
+	};
+};
+/** Skip whitespace, newlines and comments inside array brackets. */
+const skipArrayGap = (source, pos) => {
+	let i = pos;
+	for (;;) {
+		i = scanWhitespace(source, i);
+		if (source.charCodeAt(i) === HASH) {
+			i = scanComment(source, i).end;
+			continue;
+		}
+		const after = scanNewline(source, i);
+		if (after !== i) {
+			i = after;
+			continue;
+		}
+		return i;
+	}
+};
+/** Guard the inline-table single-line rule and unterminated end-of-input. */
+const checkInsideInlineTable = (source, pos, openPos) => {
+	if (pos >= source.length) raise("UnterminatedInlineTable", "inline table not closed before end of input", openPos, pos - openPos);
+	const code = source.charCodeAt(pos);
+	if (code === LF || code === CR) raise("NewlineInInlineTable", "inline tables must fit on a single line", pos, 1);
+};
+/** Whether a token that classified as `number` spells a float (never called on hex/oct/bin). */
+const isFloatToken = (token) => !/^0[xob]/.test(token) && (/[.eE]/.test(token) || token.includes("inf") || token.includes("nan"));
+/** An array value starting at `[`; `depth` is this array's own nesting count. */
+const parseArray = (source, openPos, depth) => {
+	if (depth > 256) throw new GuardExceeded("NestingDepthExceeded", 256, depth, openPos);
+	const items = [];
+	let i = openPos + 1;
+	for (;;) {
+		i = skipArrayGap(source, i);
+		if (i >= source.length) raise("UnterminatedArray", "array not closed before end of input", openPos, i - openPos);
+		if (source.charCodeAt(i) === RIGHT_BRACKET) {
+			i += 1;
+			break;
+		}
+		const item = parseValue(source, i, depth);
+		items.push(item.node);
+		i = skipArrayGap(source, item.end);
+		const code = source.charCodeAt(i);
+		if (code === COMMA) {
+			i += 1;
+			continue;
+		}
+		if (code === RIGHT_BRACKET) {
+			i += 1;
+			break;
+		}
+		if (i >= source.length) raise("UnterminatedArray", "array not closed before end of input", openPos, i - openPos);
+		raise("UnterminatedArray", "expected , or ] in array", i, 1);
+	}
+	return {
+		node: new TomlArray({
+			items,
+			offset: openPos,
+			length: i - openPos
+		}),
+		end: i
+	};
+};
+/** An inline table starting at `{`; `depth` is this table's own nesting count. */
+const parseInlineTable = (source, openPos, depth) => {
+	if (depth > 256) throw new GuardExceeded("NestingDepthExceeded", 256, depth, openPos);
+	const entries = [];
+	let i = scanWhitespace(source, openPos + 1);
+	checkInsideInlineTable(source, i, openPos);
+	if (source.charCodeAt(i) === RIGHT_BRACE) return {
+		node: new TomlInlineTable({
+			entries,
+			offset: openPos,
+			length: i + 1 - openPos
+		}),
+		end: i + 1
+	};
+	for (;;) {
+		const entryStart = i;
+		const keyPath = parseKeyPath(source, i);
+		i = scanWhitespace(source, keyPath.end);
+		checkInsideInlineTable(source, i, openPos);
+		if (source.charCodeAt(i) !== EQUALS) raise("ExpectedEquals", "expected = after key", i, 1);
+		i = scanWhitespace(source, i + 1);
+		checkInsideInlineTable(source, i, openPos);
+		const value = parseValue(source, i, depth);
+		entries.push(new TomlInlineEntry({
+			keyPath: keyPath.node,
+			value: value.node,
+			offset: entryStart,
+			length: value.end - entryStart
+		}));
+		i = scanWhitespace(source, value.end);
+		checkInsideInlineTable(source, i, openPos);
+		const code = source.charCodeAt(i);
+		if (code === RIGHT_BRACE) {
+			i += 1;
+			break;
+		}
+		if (code === COMMA) {
+			const commaPos = i;
+			i = scanWhitespace(source, i + 1);
+			checkInsideInlineTable(source, i, openPos);
+			if (source.charCodeAt(i) === RIGHT_BRACE) raise("TrailingCommaInInlineTable", "inline tables may not end with a trailing comma", commaPos, 1);
+			continue;
+		}
+		raise("UnterminatedInlineTable", "expected , or } in inline table", i, 1);
+	}
+	return {
+		node: new TomlInlineTable({
+			entries,
+			offset: openPos,
+			length: i - openPos
+		}),
+		end: i
+	};
+};
+/** Wrap a classified scalar token into its value node. */
+const scalarNode = (source, pos) => {
+	const token = scanValueToken(source, pos);
+	if (token.value === "") return raise("ExpectedValue", "expected a value", pos, 1);
+	const scalar = classifyValueToken(token.value, pos);
+	const length = token.end - pos;
+	if (typeof scalar === "boolean") return {
+		node: new TomlBoolean({
+			value: scalar,
+			offset: pos,
+			length
+		}),
+		end: token.end
+	};
+	if (typeof scalar === "bigint") return {
+		node: new TomlInteger({
+			value: scalar,
+			offset: pos,
+			length
+		}),
+		end: token.end
+	};
+	if (typeof scalar === "number") return {
+		node: isFloatToken(token.value) ? new TomlFloat({
+			value: scalar,
+			offset: pos,
+			length
+		}) : new TomlInteger({
+			value: scalar,
+			offset: pos,
+			length
+		}),
+		end: token.end
+	};
+	if (scalar instanceof TomlOffsetDateTime || scalar instanceof TomlLocalDateTime || scalar instanceof TomlLocalDate || scalar instanceof TomlLocalTime) return {
+		node: new TomlDateTimeLiteral({
+			value: scalar,
+			offset: pos,
+			length
+		}),
+		end: token.end
+	};
+	return raise("InvalidValue", `${String(scalar)} is not a valid TOML value`, pos, length);
+};
+/** A value at `pos`; `depth` is the number of containers already enclosing it. */
+const parseValue = (source, pos, depth) => {
+	const code = source.charCodeAt(pos);
+	if (pos >= source.length || code === LF || code === CR || code === HASH || code === COMMA || code === EQUALS || code === RIGHT_BRACKET || code === RIGHT_BRACE) return raise("ExpectedValue", "expected a value", pos, 1);
+	if (code === QUOTE) {
+		if (source.charCodeAt(pos + 1) === QUOTE && source.charCodeAt(pos + 2) === QUOTE) {
+			const scanned = scanMultilineBasicString(source, pos);
+			return {
+				node: new TomlString({
+					value: scanned.value,
+					style: "multiline-basic",
+					offset: pos,
+					length: scanned.end - pos
+				}),
+				end: scanned.end
+			};
+		}
+		const scanned = scanBasicString(source, pos);
+		return {
+			node: new TomlString({
+				value: scanned.value,
+				style: "basic",
+				offset: pos,
+				length: scanned.end - pos
+			}),
+			end: scanned.end
+		};
+	}
+	if (code === APOSTROPHE) {
+		if (source.charCodeAt(pos + 1) === APOSTROPHE && source.charCodeAt(pos + 2) === APOSTROPHE) {
+			const scanned = scanMultilineLiteralString(source, pos);
+			return {
+				node: new TomlString({
+					value: scanned.value,
+					style: "multiline-literal",
+					offset: pos,
+					length: scanned.end - pos
+				}),
+				end: scanned.end
+			};
+		}
+		const scanned = scanLiteralString(source, pos);
+		return {
+			node: new TomlString({
+				value: scanned.value,
+				style: "literal",
+				offset: pos,
+				length: scanned.end - pos
+			}),
+			end: scanned.end
+		};
+	}
+	if (code === LEFT_BRACKET) return parseArray(source, pos, depth + 1);
+	if (code === LEFT_BRACE) return parseInlineTable(source, pos, depth + 1);
+	return scalarNode(source, pos);
+};
+/** One `key = value` expression line; returns the position after its newline. */
+const parseKeyValueExpression = (source, lineStart, keyStart) => {
+	const keyPath = parseKeyPath(source, keyStart);
+	const equalsPos = scanWhitespace(source, keyPath.end);
+	if (source.charCodeAt(equalsPos) !== EQUALS) raise("ExpectedEquals", "expected = after key", equalsPos, 1);
+	const valueStart = scanWhitespace(source, equalsPos + 1);
+	const value = parseValue(source, valueStart, 0);
+	const lineEnd = parseLineEnd(source, value.end);
+	return {
+		node: new TomlKeyValue({
+			keyPath: keyPath.node,
+			value: value.node,
+			...lineEnd.comment !== void 0 ? { comment: lineEnd.comment } : {},
+			offset: lineStart,
+			length: lineEnd.end - lineStart
+		}),
+		end: lineEnd.end
+	};
+};
+/** One `[table]` or `[[array-of-tables]]` header line. */
+const parseHeaderExpression = (source, lineStart, bracketPos) => {
+	const isArrayTable = source.charCodeAt(bracketPos + 1) === LEFT_BRACKET;
+	const keyStart = scanWhitespace(source, bracketPos + (isArrayTable ? 2 : 1));
+	const keyPath = parseKeyPath(source, keyStart);
+	let i = scanWhitespace(source, keyPath.end);
+	if (isArrayTable) {
+		if (source.charCodeAt(i) !== RIGHT_BRACKET || source.charCodeAt(i + 1) !== RIGHT_BRACKET) raise("ExpectedTableHeaderClose", "expected ]] to close the array-of-tables header", i, 1);
+		i += 2;
+	} else {
+		if (source.charCodeAt(i) !== RIGHT_BRACKET) raise("ExpectedTableHeaderClose", "expected ] to close the table header", i, 1);
+		i += 1;
+	}
+	const lineEnd = parseLineEnd(source, i);
+	const fields = {
+		keyPath: keyPath.node,
+		...lineEnd.comment !== void 0 ? { comment: lineEnd.comment } : {},
+		offset: lineStart,
+		length: lineEnd.end - lineStart
+	};
+	return {
+		node: isArrayTable ? new TomlArrayTableHeader(fields) : new TomlTableHeader(fields),
+		end: lineEnd.end
+	};
+};
+/**
+* Parse a TOML document into its linear CST: the flat, source-tiling list of
+* expressions. Throws RawTomlError on malformed input and GuardExceeded when
+* value nesting exceeds MAX_NESTING_DEPTH; the facade (Task 7) materializes
+* both into typed errors.
+*/
+const parseExpressions = (source) => {
+	assertValidUnicode(source);
+	const expressions = [];
+	let triviaStart = -1;
+	const flushTrivia = (end) => {
+		if (triviaStart !== -1) {
+			expressions.push(new TomlTrivia({
+				text: source.slice(triviaStart, end),
+				offset: triviaStart,
+				length: end - triviaStart
+			}));
+			triviaStart = -1;
+		}
+	};
+	let pos = 0;
+	while (pos < source.length) {
+		const lineStart = pos;
+		let i = scanWhitespace(source, lineStart === 0 ? skipBom(source) : lineStart);
+		const code = source.charCodeAt(i);
+		if (i >= source.length || code === LF || code === CR || code === HASH) {
+			if (code === HASH) i = scanComment(source, i).end;
+			pos = i < source.length ? scanNewline(source, i) : i;
+			if (triviaStart === -1) triviaStart = lineStart;
+			continue;
+		}
+		flushTrivia(lineStart);
+		const parsed = code === LEFT_BRACKET ? parseHeaderExpression(source, lineStart, i) : parseKeyValueExpression(source, lineStart, i);
+		expressions.push(parsed.node);
+		pos = parsed.end;
+	}
+	flushTrivia(source.length);
+	return expressions;
+};
+
+//#endregion
+export { parseExpressions };