@rsconcept/domain 1.6.1 → 1.7.1

package/dist/syntax-errors-pCI6RicF.js

@@ -0,0 +1,689 @@
+import { annotateError } from "./rslang/ast-annotations.js";
+import { RSErrorCode } from "./rslang/error.js";
+import { visitAstDFS } from "./parsing/ast.js";
+import "./parsing/index.js";
+import { TokenID } from "./rslang/parser/token.js";
+import { TypeClass } from "./rslang/semantic/typification.js";
+import "./rslang/parser/parser.terms.js";
+//#region src/rslang/parser/syntax-errors/context.ts
+/** Skips classifiers that conflict with bracket-level diagnostics. */
+function whenNoBracketErrors(classifier) {
+	return (node, expression, context) => context.hasBracketErrors ? null : classifier(node, expression, context);
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/ast-utils.ts
+function findAncestor(node, predicate) {
+	let current = node;
+	while (current !== null) {
+		if (predicate(current)) return current;
+		current = current.parent;
+	}
+	return null;
+}
+function findRelatedNode(node, predicate) {
+	let current = node.parent;
+	while (current !== null) {
+		for (const child of current.children) if (predicate(child)) return child;
+		current = current.parent;
+	}
+	return null;
+}
+function isDescendantOf(ancestor, node) {
+	let current = node.parent;
+	while (current !== null) {
+		if (current === ancestor) return true;
+		current = current.parent;
+	}
+	return false;
+}
+function subtreeHasError(node) {
+	if (node.typeID === TokenID.ERROR) return true;
+	return node.children.some(subtreeHasError);
+}
+function isFunctionDeclNode(node) {
+	return node.typeID === 76 || node.typeID === TokenID.NT_FUNC_DEFINITION;
+}
+function isQuantifierNode(node) {
+	return node.typeID === 29;
+}
+function isFunctionNode(node) {
+	return node.typeID === 69 || node.typeID === TokenID.ID_FUNCTION;
+}
+function isPredicateNode(node) {
+	return node.typeID === 26 || node.typeID === TokenID.ID_PREDICATE;
+}
+function isFilterNode(node) {
+	return node.typeID === 59 || node.typeID === TokenID.FILTER;
+}
+function findMatchingCloseBracket(expression, openPos) {
+	if (expression[openPos] !== "[") return -1;
+	let depth = 0;
+	for (let index = openPos; index < expression.length; index++) {
+		const symbol = expression[index];
+		if (symbol === "[") depth++;
+		else if (symbol === "]") {
+			depth--;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+}
+function getErrorOperandNode(node) {
+	if (node.typeID === TokenID.ERROR) return node;
+	if (node.children.length === 1) return getErrorOperandNode(node.children[0]);
+	return null;
+}
+function isErrorPlaceholder(node) {
+	if (node.typeID === TokenID.ERROR) return true;
+	if (node.children.length === 0) return false;
+	return node.children.every((child) => isErrorPlaceholder(child));
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/function-calls.ts
+const classifyFilterParenMismatch = (node, expression) => {
+	const filterNode = findAncestor(node, isFilterNode) ?? findRelatedNode(node, isFilterNode);
+	if (filterNode === null || expression[filterNode.to] !== "(") return null;
+	return {
+		code: RSErrorCode.invalidFilterSyntax,
+		from: filterNode.from,
+		to: filterNode.to + 1
+	};
+};
+const classifyGlobalFuncCall = (node, expression) => {
+	const funcNode = findAncestor(node, (n) => isFunctionNode(n) || isPredicateNode(n)) ?? findRelatedNode(node, (n) => isFunctionNode(n) || isPredicateNode(n));
+	if (funcNode === null) return null;
+	return classifyFuncWithoutArgs(funcNode, expression);
+};
+function classifyFuncWithoutArgs(funcNode, expression) {
+	const name = expression.slice(funcNode.from, funcNode.to);
+	const rest = expression.slice(funcNode.to);
+	const withoutArgs = {
+		code: RSErrorCode.globalFuncWithoutArgs,
+		from: funcNode.from,
+		to: funcNode.to,
+		params: [name]
+	};
+	if (/^\s*$/.test(rest)) return withoutArgs;
+	if (/^\s*\(/.test(rest)) return {
+		code: RSErrorCode.globalFuncParenCall,
+		from: funcNode.from,
+		to: funcNode.to,
+		params: [name]
+	};
+	const openBracket = /^\s*\[/.exec(rest);
+	if (openBracket === null) return null;
+	const closeIdx = findMatchingCloseBracket(rest, openBracket[0].length - 1);
+	if (closeIdx >= 0 && rest.slice(openBracket[0].length, closeIdx).trim().length === 0) return withoutArgs;
+	return null;
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/error-builders.ts
+function errorAt(node, code, params) {
+	return {
+		code,
+		from: node.from,
+		to: node.to,
+		params
+	};
+}
+function hasOnlyClosingSuffix(expression, from) {
+	const suffix = expression.slice(from).trim();
+	return suffix.length === 0 || /^[\]\)\}]*$/.test(suffix);
+}
+function sliceText(node, expression) {
+	return expression.slice(node.from, node.to);
+}
+function isTextToken(node, expression, text) {
+	return sliceText(node, expression) === text;
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/generators.ts
+const classifyIncompleteGenerator = (node, expression) => detectIncompleteDeclarative(node, expression) ?? detectIncompleteImperative(node, expression) ?? detectIncompleteRecursion(node, expression);
+function detectIncompleteDeclarative(node, expression) {
+	return detectIncompleteGeneratorBody(node, expression, findAncestor(node, (target) => target.typeID === 60 || target.typeID === TokenID.NT_DECLARATIVE_EXPR), RSErrorCode.expectedDeclarativeBody, (slot) => isIncompleteDeclarativeBody(slot.nodes));
+}
+function detectIncompleteImperative(node, expression) {
+	return detectIncompleteGeneratorBody(node, expression, findAncestor(node, (target) => target.typeID === 64 || target.typeID === TokenID.NT_IMPERATIVE_EXPR), RSErrorCode.expectedImperativeBody, (slot) => isIncompleteImperativeBody(slot, expression));
+}
+function detectIncompleteRecursion(node, expression) {
+	return detectIncompleteGeneratorBody(node, expression, findAncestor(node, (target) => target.typeID === 68), RSErrorCode.expectedRecursiveBody, (slot) => isIncompleteRecursionBody(slot.nodes));
+}
+function detectIncompleteGeneratorBody(node, expression, generatorNode, code, isIncomplete) {
+	if (generatorNode === null || expression.slice(generatorNode.to).trim().length > 0) return null;
+	const slot = getGeneratorBodySlot(generatorNode, expression);
+	if (slot === null || !isIncomplete(slot) || !generatorHeaderIsValid(generatorNode, expression, slot.headerEndIndex)) return null;
+	if (!isErrorInBodySlot(node, slot, generatorNode)) return null;
+	return errorAt(node, code);
+}
+function getGeneratorBodySlot(generatorNode, expression) {
+	if (generatorNode.typeID === 60 || generatorNode.typeID === TokenID.NT_DECLARATIVE_EXPR) return getDeclarativeBodySlot(generatorNode, expression);
+	if (generatorNode.typeID === 64 || generatorNode.typeID === TokenID.NT_IMPERATIVE_EXPR) return getImperativeBodySlot(generatorNode, expression);
+	if (generatorNode.typeID === 68) return getRecursionBodySlot(generatorNode, expression);
+	return null;
+}
+function getDeclarativeBodySlot(declNode, expression) {
+	const pipeIndex = declNode.children.findIndex((child) => isTextToken(child, expression, "|"));
+	if (pipeIndex >= 0) return {
+		nodes: contentChildren(declNode, expression, pipeIndex + 1),
+		headerEndIndex: pipeIndex + 1
+	};
+	const domainNode = findDeclarativeDomain(declNode, expression);
+	if (domainNode === null) return null;
+	const domainIndex = declNode.children.indexOf(domainNode);
+	return {
+		nodes: contentChildren(declNode, expression, domainIndex + 1),
+		headerEndIndex: domainIndex + 1
+	};
+}
+function getImperativeBodySlot(impNode, expression) {
+	const pipeIndex = impNode.children.findIndex((child) => isTextToken(child, expression, "|"));
+	if (pipeIndex >= 0) return {
+		nodes: contentChildren(impNode, expression, pipeIndex + 1),
+		headerEndIndex: pipeIndex + 1
+	};
+	const tupleNode = findImperativeTuple(impNode);
+	if (tupleNode === null) return null;
+	const tupleIndex = impNode.children.indexOf(tupleNode);
+	return {
+		nodes: contentChildren(impNode, expression, tupleIndex + 1),
+		headerEndIndex: tupleIndex + 1
+	};
+}
+function getRecursionBodySlot(recNode, expression) {
+	const initNode = findRecursionInit(recNode, expression);
+	if (initNode === null) return null;
+	const initIndex = recNode.children.indexOf(initNode);
+	const afterInit = contentChildren(recNode, expression, initIndex + 1);
+	const lastPipeIndex = findLastPipeIndex(afterInit, expression);
+	if (lastPipeIndex < 0) return {
+		nodes: afterInit,
+		headerEndIndex: initIndex + 1
+	};
+	return {
+		nodes: afterInit.slice(lastPipeIndex + 1),
+		headerEndIndex: recNode.children.indexOf(afterInit[lastPipeIndex]) + 1
+	};
+}
+function contentChildren(generatorNode, expression, fromIndex) {
+	return generatorNode.children.slice(fromIndex).filter((child) => !isClosingBrace(child, expression));
+}
+function findDeclarativeDomain(declNode, expression) {
+	const inIndex = declNode.children.findIndex((child) => isTextToken(child, expression, "∈"));
+	if (inIndex < 0) return null;
+	for (let index = inIndex + 1; index < declNode.children.length; index++) {
+		const child = declNode.children[index];
+		if (isTextToken(child, expression, "|") || isClosingBrace(child, expression)) break;
+		if (child.typeID === 38) return child;
+	}
+	return null;
+}
+function findImperativeTuple(impNode) {
+	for (const child of impNode.children) if (child.typeID === 38) return child;
+	return null;
+}
+function findLastPipeIndex(nodes, expression) {
+	for (let index = nodes.length - 1; index >= 0; index--) if (isTextToken(nodes[index], expression, "|")) return index;
+	return -1;
+}
+function generatorHeaderIsValid(generatorNode, expression, headerEndIndex) {
+	for (let index = 0; index < headerEndIndex; index++) {
+		const child = generatorNode.children[index];
+		if (child.typeID === TokenID.ERROR) return false;
+		if (isStructuralGeneratorToken(child, expression)) continue;
+		if (subtreeHasError(child)) return false;
+	}
+	return true;
+}
+function isIncompleteDeclarativeBody(nodes) {
+	return isEmptyOrErrorOnlyBody(nodes);
+}
+function isIncompleteImperativeBody(slot, expression) {
+	if (slot.nodes.length === 0) return true;
+	if (slot.nodes.length === 1 && slot.nodes[0].typeID === 65) return isImpBlocksIncomplete(slot.nodes[0], expression);
+	return isEmptyOrErrorOnlyBody(slot.nodes);
+}
+function isIncompleteRecursionBody(nodes) {
+	return isEmptyOrErrorOnlyBody(nodes);
+}
+function isEmptyOrErrorOnlyBody(nodes) {
+	if (nodes.length === 0) return true;
+	if (nodes.length === 1) return isErrorPlaceholder(nodes[0]);
+	return false;
+}
+function isImpBlocksIncomplete(blocksNode, expression) {
+	if (blocksNode.children.length === 0) return true;
+	const lastChild = blocksNode.children[blocksNode.children.length - 1];
+	if (lastChild.typeID === TokenID.ERROR) return true;
+	if (isTextToken(lastChild, expression, ";")) return true;
+	if (lastChild.typeID === 38 && isErrorPlaceholder(lastChild)) return true;
+	return false;
+}
+function isErrorInBodySlot(errorNode, slot, generatorNode) {
+	if (slot.nodes.length === 0) {
+		const bodyStart = generatorNode.children[slot.headerEndIndex]?.from ?? generatorNode.from;
+		return errorNode.from >= bodyStart;
+	}
+	for (const bodyNode of slot.nodes) if (errorNode === bodyNode || isDescendantOf(bodyNode, errorNode)) {
+		if (isErrorPlaceholder(bodyNode)) return true;
+		if (bodyNode.typeID === 65 && isImpBlocksTailError(bodyNode, errorNode)) return true;
+	}
+	return false;
+}
+function isImpBlocksTailError(blocksNode, errorNode) {
+	const lastChild = blocksNode.children[blocksNode.children.length - 1];
+	return lastChild.typeID === TokenID.ERROR && (errorNode === lastChild || isDescendantOf(lastChild, errorNode));
+}
+function findRecursionInit(recursionNode, expression) {
+	const assignIndex = recursionNode.children.findIndex((child) => isTextToken(child, expression, ":="));
+	if (assignIndex < 0) return null;
+	for (let index = assignIndex + 1; index < recursionNode.children.length; index++) {
+		const child = recursionNode.children[index];
+		if (child.typeID === TokenID.ERROR) break;
+		if (isTextToken(child, expression, "|") || isClosingBrace(child, expression)) continue;
+		return child;
+	}
+	return null;
+}
+function isClosingBrace(node, expression) {
+	return node.typeID !== TokenID.ERROR && isTextToken(node, expression, "}");
+}
+function isStructuralGeneratorToken(node, expression) {
+	const text = expression.slice(node.from, node.to);
+	return text === "{" || text === "}" || text === "|" || text === "∈" || text === ":=" || text === ";";
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/trailing-slot.ts
+function detectTrailingErrorSlot(node, expression, container, options) {
+	if (container === null) return null;
+	const bodyChild = container.children[container.children.length - 1];
+	if (bodyChild?.typeID !== TokenID.ERROR || node !== bodyChild) return null;
+	if (expression.slice(container.to).trim().length > 0) return null;
+	if (options.headerValid !== void 0 && !options.headerValid(container)) return null;
+	const code = typeof options.code === "function" ? options.code(container, bodyChild) : options.code;
+	if (code === null) return null;
+	return errorAt(bodyChild, code);
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/incomplete-formal.ts
+const classifyIncompleteFormal = (node, expression, context) => detectIncompleteFunctionDecl(node, expression, context.expected) ?? detectIncompleteQuantifier(node, expression);
+function detectIncompleteFunctionDecl(node, expression, expected) {
+	return detectTrailingErrorSlot(node, expression, findAncestor(node, isFunctionDeclNode), {
+		headerValid: (container) => {
+			const argsNode = container.children.find((child) => child.typeID === 77 || child.typeID === TokenID.NT_ARGUMENTS);
+			return argsNode !== void 0 && !subtreeHasError(argsNode);
+		},
+		code: () => incompleteFormalExpressionCode(expected)
+	});
+}
+function incompleteFormalExpressionCode(expected) {
+	switch (expected) {
+		case TypeClass.function: return RSErrorCode.expectedExpressionBody;
+		case TypeClass.predicate:
+		case TypeClass.logic: return RSErrorCode.expectedLogicBody;
+		default: return RSErrorCode.expectedFunctionBody;
+	}
+}
+function detectIncompleteQuantifier(node, expression) {
+	return detectTrailingErrorSlot(node, expression, findAncestor(node, isQuantifierNode), {
+		headerValid: (container) => {
+			const varPack = container.children.find((child) => child.typeID === 31 || child.typeID === TokenID.NT_ENUM_DECL);
+			return varPack !== void 0 && !subtreeHasError(varPack);
+		},
+		code: (container, bodyChild) => {
+			const inIndex = container.children.findIndex((child) => expression.slice(child.from, child.to) === "∈");
+			if (inIndex < 0) return RSErrorCode.expectedQuantifierDomain;
+			const domainChild = container.children[inIndex + 1];
+			if (domainChild === void 0 || domainChild === bodyChild || subtreeHasError(domainChild)) return RSErrorCode.expectedQuantifierDomain;
+			return RSErrorCode.expectedQuantifierBody;
+		}
+	});
+}
+function isIncompleteGeneratorBodyCode(code) {
+	return code === RSErrorCode.expectedDeclarativeBody || code === RSErrorCode.expectedImperativeBody || code === RSErrorCode.expectedRecursiveBody;
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/incomplete-operands.ts
+const classifyIncompleteOperands = (node, expression) => detectIncompleteUnaryOperand(node, expression) ?? detectIncompleteBinaryOperand(node, expression) ?? detectIncompleteBooleanOperand(node, expression);
+const classifyIncompleteArgument = (node, expression) => detectIncompleteArgument(node, expression);
+function detectIncompleteUnaryOperand(node, expression) {
+	const unaryNode = findAncestor(node, (target) => target.typeID === 24);
+	if (unaryNode === null) return null;
+	const operandChild = unaryNode.children[unaryNode.children.length - 1];
+	if (operandChild?.typeID !== TokenID.ERROR || node !== operandChild) return null;
+	if (expression.slice(unaryNode.to).trim().length > 0) return null;
+	const operatorChild = unaryNode.children[0];
+	if (operatorChild === void 0 || operatorChild === operandChild) return null;
+	if (!isTextToken(operatorChild, expression, "¬")) return null;
+	return errorAt(operandChild, RSErrorCode.expectedUnaryOperand);
+}
+function detectIncompleteBinaryOperand(node, expression) {
+	const binaryNode = findAncestor(node, (target) => target.typeID === 33 || target.typeID === 3 || target.typeID === 44);
+	if (binaryNode === null) return null;
+	const operandChild = binaryNode.children[binaryNode.children.length - 1];
+	if (operandChild?.typeID !== TokenID.ERROR || node !== operandChild) return null;
+	if (expression.slice(binaryNode.to).trim().length > 0) return null;
+	if (binaryNode.children.length < 2) return null;
+	const leftChild = binaryNode.children[0];
+	if (leftChild.typeID === TokenID.ERROR || subtreeHasError(leftChild)) return null;
+	return errorAt(operandChild, RSErrorCode.expectedRightOperand);
+}
+function detectIncompleteBooleanOperand(node, expression) {
+	const booleanNode = findAncestor(node, (target) => target.typeID === 56);
+	if (booleanNode === null) return null;
+	const operandChild = findTrailingErrorOperand(booleanNode, expression);
+	if (operandChild === null || node !== operandChild) return null;
+	if (!hasOnlyClosingSuffix(expression, booleanNode.to)) return null;
+	return errorAt(operandChild, RSErrorCode.expectedRightOperand);
+}
+function detectIncompleteArgument(node, expression) {
+	const enumNode = findAncestor(node, (target) => target.typeID === 9);
+	if (enumNode === null || !isLegitimateArgumentEnum(enumNode, expression)) return null;
+	const errorChild = findEnumArgumentError(enumNode, expression);
+	if (errorChild === null || node !== errorChild || !hasOnlyClosingSuffix(expression, enumNode.to)) return null;
+	return errorAt(errorChild, RSErrorCode.expectedArgument);
+}
+function findTrailingErrorOperand(container, expression) {
+	for (let index = container.children.length - 1; index >= 0; index--) {
+		const child = container.children[index];
+		if (isOperandStructuralToken(child, expression)) continue;
+		return getErrorOperandNode(child);
+	}
+	return null;
+}
+function findEnumArgumentError(enumNode, expression) {
+	for (const child of enumNode.children) {
+		if (isTextToken(child, expression, ",")) continue;
+		const errorNode = getErrorOperandNode(child);
+		if (errorNode !== null) return errorNode;
+	}
+	return null;
+}
+function isOperandStructuralToken(node, expression) {
+	const text = sliceText(node, expression);
+	return text === "(" || text === ")" || text === "ℬ";
+}
+function isLegitimateArgumentEnum(enumNode, expression) {
+	return findCallHostForBracketEnum(enumNode, expression) !== null;
+}
+function findCallHostForBracketEnum(enumNode, expression) {
+	let current = enumNode.parent;
+	while (current !== null) {
+		for (const child of current.children) {
+			if (!isFunctionNode(child) && !isPredicateNode(child) && !isFilterNode(child)) continue;
+			if (isEnumInCallBrackets(enumNode, child, expression)) return child;
+		}
+		current = current.parent;
+	}
+	return null;
+}
+function isEnumInCallBrackets(enumNode, nameNode, expression) {
+	const rest = expression.slice(nameNode.to);
+	const match = /^\s*\[/.exec(rest);
+	if (match === null) return false;
+	const openPos = nameNode.to + match.index + match[0].indexOf("[");
+	const closePos = findMatchingCloseBracket(expression, openPos);
+	if (closePos < 0) return false;
+	return enumNode.from > openPos && enumNode.from < closePos;
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/classify.ts
+const PARSE_ERROR_CLASSIFIERS = [
+	classifyIncompleteFormal,
+	classifyIncompleteGenerator,
+	whenNoBracketErrors(classifyIncompleteOperands),
+	whenNoBracketErrors(classifyIncompleteArgument),
+	classifyFilterParenMismatch,
+	classifyGlobalFuncCall
+];
+/** Runs classifiers in priority order for one `ERROR` AST node. */
+function classifyParseError(node, expression, context) {
+	for (const classifier of PARSE_ERROR_CLASSIFIERS) {
+		const error = classifier(node, expression, context);
+		if (error !== null) return error;
+	}
+	return null;
+}
+/** Default rules when no classifier matched: `expectedLocal` or `unknownSyntax`. */
+function classifyFallbackError(node, ignoreUnknownErrors) {
+	const parent = node.parent;
+	if (parent === null) return ignoreUnknownErrors ? null : {
+		error: {
+			code: RSErrorCode.unknownSyntax,
+			from: node.from,
+			to: node.to
+		},
+		target: node
+	};
+	if (parent.typeID === 4) return {
+		error: {
+			code: RSErrorCode.expectedLocal,
+			from: parent.from,
+			to: parent.to
+		},
+		target: parent
+	};
+	if (ignoreUnknownErrors) return null;
+	const target = node.from === node.to ? parent : node;
+	return {
+		error: {
+			code: RSErrorCode.unknownSyntax,
+			from: target.from,
+			to: target.to
+		},
+		target
+	};
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/expression-errors.ts
+/**
+* Expression-level diagnostics (no AST required) and error deduplication.
+*/
+const ALLOWED_EXPRESSION_CHARS = buildAllowedExpressionChars();
+function buildAllowedExpressionChars() {
+	const chars = /* @__PURE__ */ new Set();
+	for (const chunk of [
+		"0123456789",
+		"abcdefghijklmnopqrstuvwxyz",
+		"ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+		"_",
+		"∅¬∀∃⇔⇒∨&ℬ+-*∪\\∆∩×∈∉⊆⊄⊂<>≥≤≠=,:;|[]{}()"
+	]) for (const symbol of chunk) chars.add(symbol);
+	for (let codePoint = 945; codePoint <= 969; codePoint++) chars.add(String.fromCodePoint(codePoint));
+	return chars;
+}
+function isAllowedExpressionChar(symbol) {
+	return /\s/u.test(symbol) || ALLOWED_EXPRESSION_CHARS.has(symbol);
+}
+function extractForbiddenCharacterErrors(expression) {
+	const errors = [];
+	let pos = 0;
+	while (pos < expression.length) {
+		const symbol = expression[pos];
+		if (isAllowedExpressionChar(symbol)) {
+			pos++;
+			continue;
+		}
+		const start = pos;
+		while (pos < expression.length && !isAllowedExpressionChar(expression[pos])) pos++;
+		errors.push({
+			code: RSErrorCode.forbiddenCharacter,
+			from: start,
+			to: pos,
+			params: [expression.slice(start, pos)]
+		});
+	}
+	return errors;
+}
+function extractBracketErrors(expression) {
+	const stack = [];
+	for (let pos = 0; pos < expression.length; pos++) {
+		const symbol = expression[pos];
+		if (isOpenBracket(symbol)) {
+			if (isDoubleParenthesis(expression, pos)) return {
+				code: RSErrorCode.doubleParenthesis,
+				from: pos,
+				to: pos + 2
+			};
+			stack.push({
+				bracket: symbol,
+				index: pos
+			});
+			continue;
+		}
+		if (!isCloseBracket(symbol)) continue;
+		const expectedOpen = closeToOpen(symbol);
+		const top = stack[stack.length - 1];
+		if (top === void 0) return {
+			code: RSErrorCode.missingOpenBracket,
+			from: pos,
+			to: pos + 1,
+			params: [symbol]
+		};
+		if (top.bracket !== expectedOpen) return {
+			code: RSErrorCode.bracketMismatch,
+			from: pos,
+			to: pos + 1,
+			params: [openToClose(top.bracket), symbol]
+		};
+		stack.pop();
+	}
+	if (stack.length > 0) {
+		const unclosed = stack[0];
+		return {
+			code: RSErrorCode.missingCloseBracket,
+			from: unclosed.index,
+			to: unclosed.index + 1,
+			params: [unclosed.bracket]
+		};
+	}
+	return null;
+}
+function deduplicateErrors(errors) {
+	const result = [];
+	for (const error of errors) {
+		if (result.some((existing) => existing.code === error.code && existing.from === error.from && existing.to === error.to)) continue;
+		if (error.code !== RSErrorCode.unknownSyntax) {
+			for (let index = result.length - 1; index >= 0; index--) if (result[index].code === RSErrorCode.unknownSyntax && rangesOverlap(error, result[index])) result.splice(index, 1);
+		}
+		result.push(error);
+	}
+	const specific = result.filter((error) => error.code !== RSErrorCode.unknownSyntax);
+	return collapseContiguousUnknownSyntax(result.filter((error) => error.code !== RSErrorCode.unknownSyntax || !specific.some((item) => rangesOverlap(error, item))));
+}
+function collapseContiguousUnknownSyntax(errors) {
+	const unknowns = errors.filter((error) => error.code === RSErrorCode.unknownSyntax);
+	if (unknowns.length <= 1) return errors;
+	const others = errors.filter((error) => error.code !== RSErrorCode.unknownSyntax);
+	const first = [...unknowns].sort((left, right) => left.from - right.from)[0];
+	return [...others, first];
+}
+function rangesOverlap(a, b) {
+	return a.from < b.to && b.from < a.to;
+}
+function isOpenBracket(symbol) {
+	return symbol === "(" || symbol === "[" || symbol === "{";
+}
+function isCloseBracket(symbol) {
+	return symbol === ")" || symbol === "]" || symbol === "}";
+}
+function openToClose(symbol) {
+	switch (symbol) {
+		case "(": return ")";
+		case "[": return "]";
+		case "{": return "}";
+	}
+}
+function closeToOpen(symbol) {
+	switch (symbol) {
+		case ")": return "(";
+		case "]": return "[";
+		case "}": return "{";
+	}
+}
+function isDoubleParenthesis(expression, pos) {
+	if (!(expression[pos] === "(" && expression[pos + 1] === "(")) return false;
+	const outerClose = findMatchingCloseParen(expression, pos);
+	const innerClose = findMatchingCloseParen(expression, pos + 1);
+	if (outerClose < 0 || innerClose < 0) return false;
+	return outerClose === innerClose + 1;
+}
+function findMatchingCloseParen(expression, openPos) {
+	if (expression[openPos] !== "(") return -1;
+	const stack = [];
+	for (let index = openPos; index < expression.length; index++) {
+		const symbol = expression[index];
+		if (isOpenBracket(symbol)) {
+			stack.push(symbol);
+			continue;
+		}
+		if (!isCloseBracket(symbol)) continue;
+		const top = stack.pop();
+		if (top === void 0 || top !== closeToOpen(symbol)) return -1;
+		if (stack.length === 0) return index;
+	}
+	return -1;
+}
+//#endregion
+//#region src/rslang/parser/syntax-errors/index.ts
+/**
+* Syntax error extraction — public entry point.
+*
+* Expects the **hybrid** AST produced by `normalizeAST` (see `parser/README.md`).
+* See {@link ./README.md} for pipeline, classifier order, and how to add codes.
+*
+* @module rslang/parser/syntax-errors
+*/
+/**
+* Walks a parsed expression AST and reports syntax errors.
+*
+* @param ast - Root AST from `buildTree(parser.parse(expression))`
+* @param expression - Original source text (positions must match the AST)
+* @param reporter - Called once per deduplicated error
+* @param annotateErrors - When true, also calls `annotateError` on the triggering node
+* @param options - Optional typification hint for incomplete formal expressions
+*/
+function extractSyntaxErrors(ast, expression, reporter, annotateErrors = false, options) {
+	const forbiddenErrors = extractForbiddenCharacterErrors(expression);
+	if (forbiddenErrors.length > 0) {
+		for (const error of forbiddenErrors) {
+			reporter(error);
+			if (annotateErrors) annotateError(ast, error.code, error.params);
+		}
+		return;
+	}
+	const collected = [];
+	const annotationTargets = /* @__PURE__ */ new Map();
+	const collect = (error, target) => {
+		collected.push(error);
+		if (target !== void 0) annotationTargets.set(error, target);
+	};
+	const bracketError = extractBracketErrors(expression);
+	const hasBracketErrors = bracketError !== null;
+	visitAstDFS(ast, (node) => extractInternal(node, expression, collect, hasBracketErrors, options));
+	const hasIncompleteGenerator = collected.some((error) => isIncompleteGeneratorBodyCode(error.code));
+	if (bracketError !== null && !hasIncompleteGenerator) collect(bracketError, ast);
+	for (const error of deduplicateErrors(collected)) {
+		reporter(error);
+		if (annotateErrors) {
+			const target = annotationTargets.get(error);
+			if (target !== void 0) annotateError(target, error.code, error.params);
+		}
+	}
+}
+function extractInternal(node, expression, collect, hasBracketErrors, options) {
+	if (node.typeID !== TokenID.ERROR) return;
+	const classified = classifyParseError(node, expression, {
+		hasBracketErrors,
+		expected: options?.expected
+	});
+	if (classified !== null) {
+		collect(classified, node);
+		return;
+	}
+	const fallback = classifyFallbackError(node, hasBracketErrors);
+	if (fallback !== null) collect(fallback.error, fallback.target);
+}
+//#endregion
+export { extractSyntaxErrors as t };
+
+//# sourceMappingURL=syntax-errors-pCI6RicF.js.map