@revisium/formula 0.8.0 → 0.9.0

package/dist/validate-syntax-CmqnFrsc.mjs

@@ -0,0 +1,1421 @@
+import * as ohm from "ohm-js";
+
+//#region src/ohm/grammar/index.ts
+const grammarText = String.raw`Formula {
+  Expression = Ternary
+
+  // Ternary: condition ? then : else
+  Ternary
+    = LogicalOr "?" Ternary ":" Ternary  -- ternary
+    | LogicalOr
+
+  // Logical OR: a || b
+  LogicalOr
+    = LogicalOr "||" LogicalAnd  -- or
+    | LogicalAnd
+
+  // Logical AND: a && b
+  LogicalAnd
+    = LogicalAnd "&&" Equality  -- and
+    | Equality
+
+  // Equality: a == b, a != b
+  Equality
+    = Equality "==" Comparison  -- eq
+    | Equality "!=" Comparison  -- neq
+    | Comparison
+
+  // Comparison: a > b, a < b, a >= b, a <= b
+  Comparison
+    = Comparison ">=" Additive  -- gte
+    | Comparison "<=" Additive  -- lte
+    | Comparison ">" Additive   -- gt
+    | Comparison "<" Additive   -- lt
+    | Additive
+
+  // Additive: a + b, a - b
+  Additive
+    = Additive "+" Multiplicative  -- plus
+    | Additive "-" Multiplicative  -- minus
+    | Multiplicative
+
+  // Multiplicative: a * b, a / b, a % b
+  Multiplicative
+    = Multiplicative "*" Unary  -- times
+    | Multiplicative "/" Unary  -- div
+    | Multiplicative "%" Unary  -- mod
+    | Unary
+
+  // Unary: -a, !a
+  Unary
+    = "-" Unary  -- neg
+    | "!" Unary  -- not
+    | Postfix
+
+  // Postfix: function calls, property access, array access
+  Postfix
+    = Postfix "(" Arguments? ")"      -- call
+    | Postfix "." identifier          -- property
+    | Postfix "[" Expression "]"      -- index
+    | Postfix "[" "*" "]"             -- wildcard
+    | Primary
+
+  // Arguments for function calls
+  Arguments
+    = Expression ("," Expression)*
+
+  // Primary expressions
+  Primary
+    = "(" Expression ")"              -- paren
+    | "[" string "]"                  -- bracketedField
+    | number
+    | string
+    | boolean
+    | null
+    | rootPath
+    | relativePath
+    | contextToken
+    | identifier
+
+  // Literals
+  number
+    = "-"? digit+ "." digit+  -- float
+    | "-"? digit+             -- int
+
+  string
+    = "\"" doubleStringChar* "\""
+    | "'" singleStringChar* "'"
+
+  doubleStringChar
+    = ~("\"" | "\\") any  -- regular
+    | "\\" any            -- escape
+
+  singleStringChar
+    = ~("'" | "\\") any   -- regular
+    | "\\" any            -- escape
+
+  boolean
+    = "true" ~identifierPart   -- true
+    | "false" ~identifierPart  -- false
+
+  null = "null" ~identifierPart
+
+  // Identifiers and paths
+  identifier = ~reserved identifierStart identifierPart*
+
+  identifierStart = letter | "_"
+  identifierPart = letter | digit | "_"
+
+  // Special paths
+  rootPath = "/" identifierPart+
+
+  relativePathPrefix = ".." "/"
+  relativePath = relativePathPrefix+ identifierPart+
+
+  contextToken
+    = "@" contextPath       -- at
+    | "#" contextPath       -- hash
+
+  contextPath
+    = "parent" "." contextPath  -- parent
+    | "root" "." contextPathEnd -- root
+    | contextPathEnd            -- simple
+
+  contextPathEnd = identifierPart+
+
+  // Reserved words (cannot be used as identifiers)
+  reserved
+    = ("true" | "false" | "null") ~identifierPart
+
+  // Whitespace (implicit, Ohm handles automatically)
+}`;
+const grammar = ohm.grammar(grammarText);
+
+//#endregion
+//#region src/ohm/semantics/index.ts
+function isSafePropertyName(name) {
+	return name !== "__proto__";
+}
+function childrenToAST(children) {
+	return children.filter((c) => "toAST" in c).map((c) => c.toAST());
+}
+function childrenDependencies(children) {
+	return children.filter((c) => "dependencies" in c).flatMap((c) => c.dependencies());
+}
+function childrenFeatures(children) {
+	return children.filter((c) => "features" in c).flatMap((c) => c.features());
+}
+const semantics = grammar.createSemantics();
+semantics.addOperation("toAST", {
+	Expression(e) {
+		return e.toAST();
+	},
+	Ternary_ternary(cond, _q, cons, _c, alt) {
+		return {
+			type: "TernaryOp",
+			condition: cond.toAST(),
+			consequent: cons.toAST(),
+			alternate: alt.toAST()
+		};
+	},
+	Ternary(e) {
+		return e.toAST();
+	},
+	LogicalOr_or(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "||",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	LogicalOr(e) {
+		return e.toAST();
+	},
+	LogicalAnd_and(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "&&",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	LogicalAnd(e) {
+		return e.toAST();
+	},
+	Equality_eq(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "==",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Equality_neq(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "!=",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Equality(e) {
+		return e.toAST();
+	},
+	Comparison_gte(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: ">=",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Comparison_lte(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "<=",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Comparison_gt(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: ">",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Comparison_lt(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "<",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Comparison(e) {
+		return e.toAST();
+	},
+	Additive_plus(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "+",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Additive_minus(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "-",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Additive(e) {
+		return e.toAST();
+	},
+	Multiplicative_times(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "*",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Multiplicative_div(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "/",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Multiplicative_mod(left, _op, right) {
+		return {
+			type: "BinaryOp",
+			op: "%",
+			left: left.toAST(),
+			right: right.toAST()
+		};
+	},
+	Multiplicative(e) {
+		return e.toAST();
+	},
+	Unary_neg(_op, expr) {
+		return {
+			type: "UnaryOp",
+			op: "-",
+			argument: expr.toAST()
+		};
+	},
+	Unary_not(_op, expr) {
+		return {
+			type: "UnaryOp",
+			op: "!",
+			argument: expr.toAST()
+		};
+	},
+	Unary(e) {
+		return e.toAST();
+	},
+	Postfix_call(callee, _lp, args, _rp) {
+		const firstArg = args.children[0];
+		const argList = firstArg ? firstArg.toAST() : [];
+		return {
+			type: "CallExpression",
+			callee: callee.toAST(),
+			arguments: Array.isArray(argList) ? argList : [argList]
+		};
+	},
+	Postfix_property(obj, _dot, prop) {
+		return {
+			type: "MemberExpression",
+			object: obj.toAST(),
+			property: prop.sourceString
+		};
+	},
+	Postfix_index(obj, _lb, index, _rb) {
+		const indexAST = index.toAST();
+		if (indexAST.type === "StringLiteral") return {
+			type: "BracketedMemberExpression",
+			object: obj.toAST(),
+			property: indexAST.value
+		};
+		return {
+			type: "IndexExpression",
+			object: obj.toAST(),
+			index: indexAST
+		};
+	},
+	Postfix_wildcard(obj, _lb, _star, _rb) {
+		return {
+			type: "WildcardExpression",
+			object: obj.toAST()
+		};
+	},
+	Postfix(e) {
+		return e.toAST();
+	},
+	Arguments(first, _comma, rest) {
+		return [first.toAST(), ...rest.children.map((c) => c.toAST())];
+	},
+	Primary_paren(_lp, expr, _rp) {
+		return expr.toAST();
+	},
+	Primary_bracketedField(_lb, str, _rb) {
+		return {
+			type: "BracketedIdentifier",
+			name: str.toAST().value
+		};
+	},
+	Primary(e) {
+		return e.toAST();
+	},
+	number_float(_neg, _int, _dot, _frac) {
+		return {
+			type: "NumberLiteral",
+			value: Number.parseFloat(this.sourceString)
+		};
+	},
+	number_int(_neg, _digits) {
+		return {
+			type: "NumberLiteral",
+			value: Number.parseInt(this.sourceString, 10)
+		};
+	},
+	string(_open, chars, _close) {
+		return {
+			type: "StringLiteral",
+			value: chars.sourceString.replaceAll(/\\(.)/g, "$1")
+		};
+	},
+	boolean_true(_) {
+		return {
+			type: "BooleanLiteral",
+			value: true
+		};
+	},
+	boolean_false(_) {
+		return {
+			type: "BooleanLiteral",
+			value: false
+		};
+	},
+	null(_) {
+		return { type: "NullLiteral" };
+	},
+	identifier(_start, _rest) {
+		return {
+			type: "Identifier",
+			name: this.sourceString
+		};
+	},
+	rootPath(_slash, _path) {
+		return {
+			type: "RootPath",
+			path: this.sourceString
+		};
+	},
+	relativePath(_dotSlashes, _parts) {
+		return {
+			type: "RelativePath",
+			path: this.sourceString
+		};
+	},
+	contextToken_at(_at, _path) {
+		return {
+			type: "ContextToken",
+			name: this.sourceString
+		};
+	},
+	contextToken_hash(_hash, _path) {
+		return {
+			type: "ContextToken",
+			name: this.sourceString
+		};
+	},
+	_iter(...children) {
+		return childrenToAST(children);
+	},
+	_terminal() {
+		return {
+			type: "Identifier",
+			name: this.sourceString
+		};
+	}
+});
+semantics.addOperation("dependencies", {
+	identifier(_start, _rest) {
+		return [this.sourceString];
+	},
+	Primary_bracketedField(_lb, _str, _rb) {
+		return [this.sourceString];
+	},
+	rootPath(_slash, _path) {
+		return [this.sourceString];
+	},
+	relativePath(_dotSlashes, _parts) {
+		return [this.sourceString];
+	},
+	contextToken_at(_at, _path) {
+		return [];
+	},
+	contextToken_hash(_hash, _path) {
+		return [];
+	},
+	Postfix_property(obj, _dot, prop) {
+		const objDeps = obj.dependencies();
+		if (objDeps.length === 1) return [`${objDeps[0]}.${prop.sourceString}`];
+		return objDeps;
+	},
+	Postfix_index(obj, _lb, index, _rb) {
+		const objDeps = obj.dependencies();
+		const indexNode = index.toAST();
+		if (indexNode.type === "StringLiteral") {
+			const strValue = indexNode.value;
+			const quote = this.sourceString.includes("\"") ? "\"" : "'";
+			if (objDeps.length === 1) return [`${objDeps[0]}[${quote}${strValue}${quote}]`];
+			return objDeps;
+		}
+		const getNumericIndex = (node) => {
+			if (node.type === "NumberLiteral") return node.value;
+			if (node.type === "UnaryOp" && node.op === "-" && node.argument.type === "NumberLiteral") return -node.argument.value;
+			return null;
+		};
+		const numericIndex = getNumericIndex(indexNode);
+		if (objDeps.length === 1 && numericIndex !== null) return [`${objDeps[0]}[${numericIndex}]`];
+		return [...objDeps, ...index.dependencies()];
+	},
+	Postfix_wildcard(obj, _lb, _star, _rb) {
+		const objDeps = obj.dependencies();
+		if (objDeps.length === 1) return [`${objDeps[0]}[*]`];
+		return objDeps;
+	},
+	Postfix_call(callee, _lp, args, _rp) {
+		const calleeDeps = callee.dependencies();
+		const calleeAST = callee.toAST();
+		const argDeps = childrenDependencies(args.children);
+		if (calleeAST.type === "Identifier") return argDeps;
+		return [...calleeDeps, ...argDeps];
+	},
+	number_float(_neg, _int, _dot, _frac) {
+		return [];
+	},
+	number_int(_neg, _digits) {
+		return [];
+	},
+	string(_open, _chars, _close) {
+		return [];
+	},
+	boolean_true(_) {
+		return [];
+	},
+	boolean_false(_) {
+		return [];
+	},
+	null(_) {
+		return [];
+	},
+	_nonterminal(...children) {
+		return childrenDependencies(children);
+	},
+	_iter(...children) {
+		return childrenDependencies(children);
+	},
+	_terminal() {
+		return [];
+	}
+});
+const ARRAY_FUNCTIONS = new Set([
+	"sum",
+	"avg",
+	"count",
+	"first",
+	"last",
+	"join",
+	"includes"
+]);
+semantics.addOperation("features", {
+	Primary_bracketedField(_lb, _str, _rb) {
+		return ["bracket_notation"];
+	},
+	rootPath(_slash, _path) {
+		const path = this.sourceString;
+		const features = ["root_path"];
+		if (path.includes(".")) features.push("nested_path");
+		return features;
+	},
+	relativePath(_dotSlashes, _parts) {
+		const path = this.sourceString;
+		const features = ["relative_path"];
+		if (path.replace(/^(\.\.\/)+/, "").includes(".")) features.push("nested_path");
+		return features;
+	},
+	contextToken_at(_at, _path) {
+		return ["context_token"];
+	},
+	contextToken_hash(_hash, _path) {
+		return ["context_token"];
+	},
+	Postfix_property(obj, _dot, _prop) {
+		return [...obj.features(), "nested_path"];
+	},
+	Postfix_index(obj, _lb, index, _rb) {
+		const objFeatures = obj.features();
+		const indexFeatures = index.features();
+		if (index.toAST().type === "StringLiteral") return [
+			...objFeatures,
+			...indexFeatures,
+			"bracket_notation"
+		];
+		return [
+			...objFeatures,
+			...indexFeatures,
+			"array_index"
+		];
+	},
+	Postfix_wildcard(obj, _lb, _star, _rb) {
+		return [...obj.features(), "array_wildcard"];
+	},
+	Postfix_call(callee, _lp, args, _rp) {
+		const calleeAST = callee.toAST();
+		const argFeatures = childrenFeatures(args.children);
+		if (calleeAST.type === "Identifier" && ARRAY_FUNCTIONS.has(calleeAST.name.toLowerCase())) return [...argFeatures, "array_function"];
+		return argFeatures;
+	},
+	_nonterminal(...children) {
+		return childrenFeatures(children);
+	},
+	_iter(...children) {
+		return childrenFeatures(children);
+	},
+	_terminal() {
+		return [];
+	}
+});
+const BUILTINS = {
+	and: (a, b) => Boolean(a) && Boolean(b),
+	or: (a, b) => Boolean(a) || Boolean(b),
+	not: (a) => !a,
+	concat: (...args) => args.map(String).join(""),
+	upper: (s) => String(s).toUpperCase(),
+	lower: (s) => String(s).toLowerCase(),
+	trim: (s) => String(s).trim(),
+	left: (s, n) => String(s).slice(0, Math.max(0, Math.floor(Number(n)))),
+	right: (s, n) => {
+		const str = String(s);
+		const count = Math.max(0, Math.floor(Number(n)));
+		return count === 0 ? "" : str.slice(-count);
+	},
+	replace: (s, search, repl) => String(s).replace(String(search), String(repl)),
+	tostring: String,
+	length: (s) => {
+		if (Array.isArray(s)) return s.length;
+		if (typeof s === "string") return s.length;
+		if (s !== null && typeof s === "object") return Object.keys(s).length;
+		return String(s).length;
+	},
+	contains: (s, search) => String(s).includes(String(search)),
+	startswith: (s, search) => String(s).startsWith(String(search)),
+	endswith: (s, search) => String(s).endsWith(String(search)),
+	join: (arr, sep) => {
+		if (!Array.isArray(arr)) return "";
+		if (sep === void 0 || sep === null) return arr.join(",");
+		if (typeof sep !== "string" && typeof sep !== "number") return arr.join(",");
+		return arr.join(String(sep));
+	},
+	tonumber: Number,
+	toboolean: Boolean,
+	isnull: (v) => v === null || v === void 0,
+	coalesce: (...args) => args.find((v) => v !== null && v !== void 0) ?? null,
+	round: (n, dec) => {
+		const factor = 10 ** (dec === void 0 ? 0 : Number(dec));
+		return Math.round(Number(n) * factor) / factor;
+	},
+	floor: (n) => Math.floor(Number(n)),
+	ceil: (n) => Math.ceil(Number(n)),
+	abs: (n) => Math.abs(Number(n)),
+	sqrt: (n) => Math.sqrt(Number(n)),
+	pow: (base, exp) => Math.pow(Number(base), Number(exp)),
+	min: (...args) => args.length === 0 ? NaN : Math.min(...args.map(Number)),
+	max: (...args) => args.length === 0 ? NaN : Math.max(...args.map(Number)),
+	log: (n) => Math.log(Number(n)),
+	log10: (n) => Math.log10(Number(n)),
+	exp: (n) => Math.exp(Number(n)),
+	sign: (n) => Math.sign(Number(n)),
+	sum: (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a + Number(b), 0) : 0,
+	avg: (arr) => Array.isArray(arr) && arr.length > 0 ? arr.reduce((a, b) => a + Number(b), 0) / arr.length : 0,
+	count: (arr) => Array.isArray(arr) ? arr.length : 0,
+	first: (arr) => Array.isArray(arr) ? arr[0] : void 0,
+	last: (arr) => Array.isArray(arr) ? arr.at(-1) : void 0,
+	includes: (arr, val) => Array.isArray(arr) ? arr.includes(val) : false,
+	if: (cond, ifTrue, ifFalse) => cond ? ifTrue : ifFalse
+};
+function getByPath(obj, path) {
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current === null || current === void 0) return void 0;
+		current = current[part];
+	}
+	return current;
+}
+semantics.addOperation("eval(ctx)", {
+	Expression(e) {
+		return e.eval(this.args.ctx);
+	},
+	Ternary_ternary(cond, _q, cons, _c, alt) {
+		return cond.eval(this.args.ctx) ? cons.eval(this.args.ctx) : alt.eval(this.args.ctx);
+	},
+	Ternary(e) {
+		return e.eval(this.args.ctx);
+	},
+	LogicalOr_or(left, _op, right) {
+		return left.eval(this.args.ctx) || right.eval(this.args.ctx);
+	},
+	LogicalOr(e) {
+		return e.eval(this.args.ctx);
+	},
+	LogicalAnd_and(left, _op, right) {
+		return left.eval(this.args.ctx) && right.eval(this.args.ctx);
+	},
+	LogicalAnd(e) {
+		return e.eval(this.args.ctx);
+	},
+	Equality_eq(left, _op, right) {
+		return left.eval(this.args.ctx) == right.eval(this.args.ctx);
+	},
+	Equality_neq(left, _op, right) {
+		return left.eval(this.args.ctx) != right.eval(this.args.ctx);
+	},
+	Equality(e) {
+		return e.eval(this.args.ctx);
+	},
+	Comparison_gte(left, _op, right) {
+		return left.eval(this.args.ctx) >= right.eval(this.args.ctx);
+	},
+	Comparison_lte(left, _op, right) {
+		return left.eval(this.args.ctx) <= right.eval(this.args.ctx);
+	},
+	Comparison_gt(left, _op, right) {
+		return left.eval(this.args.ctx) > right.eval(this.args.ctx);
+	},
+	Comparison_lt(left, _op, right) {
+		return left.eval(this.args.ctx) < right.eval(this.args.ctx);
+	},
+	Comparison(e) {
+		return e.eval(this.args.ctx);
+	},
+	Additive_plus(left, _op, right) {
+		const l = left.eval(this.args.ctx);
+		const r = right.eval(this.args.ctx);
+		if (typeof l === "string" || typeof r === "string") return String(l) + String(r);
+		return l + r;
+	},
+	Additive_minus(left, _op, right) {
+		return left.eval(this.args.ctx) - right.eval(this.args.ctx);
+	},
+	Additive(e) {
+		return e.eval(this.args.ctx);
+	},
+	Multiplicative_times(left, _op, right) {
+		return left.eval(this.args.ctx) * right.eval(this.args.ctx);
+	},
+	Multiplicative_div(left, _op, right) {
+		return left.eval(this.args.ctx) / right.eval(this.args.ctx);
+	},
+	Multiplicative_mod(left, _op, right) {
+		return left.eval(this.args.ctx) % right.eval(this.args.ctx);
+	},
+	Multiplicative(e) {
+		return e.eval(this.args.ctx);
+	},
+	Unary_neg(_op, expr) {
+		return -expr.eval(this.args.ctx);
+	},
+	Unary_not(_op, expr) {
+		return !expr.eval(this.args.ctx);
+	},
+	Unary(e) {
+		return e.eval(this.args.ctx);
+	},
+	Postfix_call(callee, _lp, args, _rp) {
+		const calleeAST = callee.toAST();
+		const getArgValues = () => {
+			const argsNode = args.children[0];
+			if (!argsNode) return [];
+			return argsNode.eval(this.args.ctx);
+		};
+		if (calleeAST.type === "Identifier") {
+			const builtinFn = BUILTINS[calleeAST.name.toLowerCase()];
+			if (builtinFn) return builtinFn(...getArgValues());
+		}
+		const fn = callee.eval(this.args.ctx);
+		if (typeof fn === "function") return fn(...getArgValues());
+		const calleeName = calleeAST.type === "Identifier" ? calleeAST.name : "expression";
+		throw new Error(`'${calleeName}' is not a function`);
+	},
+	Postfix_property(obj, _dot, prop) {
+		return obj.eval(this.args.ctx)?.[prop.sourceString];
+	},
+	Postfix_index(obj, _lb, index, _rb) {
+		const objVal = obj.eval(this.args.ctx);
+		const idx = index.eval(this.args.ctx);
+		if (typeof idx === "string") {
+			if (!isSafePropertyName(idx)) return;
+			return objVal?.[idx];
+		}
+		const numIdx = idx;
+		if (numIdx < 0) return objVal?.[objVal.length + numIdx];
+		return objVal?.[numIdx];
+	},
+	Postfix_wildcard(obj, _lb, _star, _rb) {
+		return obj.eval(this.args.ctx);
+	},
+	Postfix(e) {
+		return e.eval(this.args.ctx);
+	},
+	Arguments(first, _comma, rest) {
+		return [first.eval(this.args.ctx), ...rest.children.map((c) => c.eval(this.args.ctx))];
+	},
+	Primary_paren(_lp, expr, _rp) {
+		return expr.eval(this.args.ctx);
+	},
+	Primary_bracketedField(_lb, str, _rb) {
+		const fieldName = str.eval(this.args.ctx);
+		if (!isSafePropertyName(fieldName)) return;
+		return this.args.ctx[fieldName];
+	},
+	Primary(e) {
+		return e.eval(this.args.ctx);
+	},
+	number_float(_neg, _int, _dot, _frac) {
+		return Number.parseFloat(this.sourceString);
+	},
+	number_int(_neg, _digits) {
+		return Number.parseInt(this.sourceString, 10);
+	},
+	string(_open, chars, _close) {
+		return chars.sourceString.replaceAll(/\\(.)/g, "$1");
+	},
+	boolean_true(_) {
+		return true;
+	},
+	boolean_false(_) {
+		return false;
+	},
+	null(_) {
+		return null;
+	},
+	identifier(_start, _rest) {
+		const name = this.sourceString;
+		return this.args.ctx[name];
+	},
+	rootPath(_slash, _path) {
+		const fullPath = this.sourceString;
+		if (fullPath in this.args.ctx) return this.args.ctx[fullPath];
+		const parts = fullPath.slice(1).split(".");
+		const firstPart = parts[0];
+		if (!firstPart) return void 0;
+		const rootKey = "/" + firstPart;
+		let value = this.args.ctx[rootKey];
+		for (let i = 1; i < parts.length; i++) {
+			if (value === null || value === void 0) return void 0;
+			const part = parts[i];
+			if (!part) continue;
+			value = value[part];
+		}
+		return value;
+	},
+	relativePath(_dotSlashes, _parts) {
+		const fullPath = this.sourceString;
+		if (fullPath in this.args.ctx) return this.args.ctx[fullPath];
+		const path = fullPath.replace(/^(\.\.\/)+/, "");
+		return getByPath(this.args.ctx, path);
+	},
+	contextToken_at(_at, _path) {
+		return this.args.ctx[this.sourceString];
+	},
+	contextToken_hash(_hash, _path) {
+		return this.args.ctx[this.sourceString];
+	},
+	_nonterminal(...children) {
+		const ctx = this.args.ctx;
+		for (const child of children) if ("eval" in child) return child.eval(ctx);
+	},
+	_iter(...children) {
+		return children.map((c) => c.eval(this.args.ctx));
+	},
+	_terminal() {}
+});
+
+//#endregion
+//#region src/ohm/core/parser.ts
+function detectMinVersion(features) {
+	if (features.includes("context_token")) return "1.2";
+	if (features.length > 0) return "1.1";
+	return "1.0";
+}
+function parseFormula(expression) {
+	const trimmed = expression.trim();
+	if (!trimmed) throw new Error("Empty expression");
+	const matchResult = grammar.match(trimmed);
+	if (matchResult.failed()) throw new Error(matchResult.message ?? "Parse error");
+	const adapter = semantics(matchResult);
+	const ast = adapter.toAST();
+	const dependencies = [...new Set(adapter.dependencies())];
+	const allFeatures = adapter.features();
+	const features = [...new Set(allFeatures)];
+	return {
+		ast,
+		dependencies,
+		features,
+		minVersion: detectMinVersion(features)
+	};
+}
+function validateSyntax(expression) {
+	const trimmed = expression.trim();
+	if (!trimmed) return {
+		isValid: false,
+		error: "Empty expression"
+	};
+	const matchResult = grammar.match(trimmed);
+	if (matchResult.failed()) {
+		const pos = matchResult.getRightmostFailurePosition?.();
+		return {
+			isValid: false,
+			error: matchResult.message ?? "Parse error",
+			position: pos
+		};
+	}
+	return { isValid: true };
+}
+function evaluate(expression, context) {
+	const trimmed = expression.trim();
+	if (!trimmed) throw new Error("Empty expression");
+	const matchResult = grammar.match(trimmed);
+	if (matchResult.failed()) throw new Error(matchResult.message ?? "Parse error");
+	const safeContext = {};
+	for (const [key, value] of Object.entries(context)) if (typeof value !== "function") safeContext[key] = value;
+	return semantics(matchResult).eval(safeContext);
+}
+function parseCurrentPath(currentPath) {
+	const segments = [];
+	let current = "";
+	let inBracket = false;
+	for (const char of currentPath) if (char === "[") {
+		inBracket = true;
+		current += char;
+	} else if (char === "]") {
+		inBracket = false;
+		current += char;
+	} else if (char === "." && !inBracket) {
+		if (current) {
+			segments.push(current);
+			current = "";
+		}
+	} else current += char;
+	if (current) segments.push(current);
+	return segments;
+}
+function getValueByPath(data, path) {
+	const segments = parseCurrentPath(path);
+	let current = data;
+	for (const segment of segments) {
+		if (current === null || current === void 0) return;
+		if (typeof current !== "object") return;
+		const bracketMatch = /^([^[]+)\[(\d+)\]$/.exec(segment);
+		if (bracketMatch?.[1] && bracketMatch[2]) {
+			const fieldName = bracketMatch[1];
+			const index = Number.parseInt(bracketMatch[2], 10);
+			const arr = current[fieldName];
+			if (!Array.isArray(arr)) return;
+			current = arr[index];
+		} else current = current[segment];
+	}
+	return current;
+}
+function extractRootField(fieldPath) {
+	const dotIndex = fieldPath.indexOf(".");
+	const bracketIndex = fieldPath.indexOf("[");
+	if (dotIndex === -1 && bracketIndex === -1) return fieldPath;
+	if (dotIndex === -1) return fieldPath.slice(0, bracketIndex);
+	if (bracketIndex === -1) return fieldPath.slice(0, dotIndex);
+	return fieldPath.slice(0, Math.min(dotIndex, bracketIndex));
+}
+function countParentLevels(path) {
+	let count = 0;
+	let remaining = path;
+	while (remaining.startsWith("../")) {
+		count++;
+		remaining = remaining.slice(3);
+	}
+	return count;
+}
+function getPathAfterParents(path) {
+	return path.replace(/^(\.\.\/)+/, "");
+}
+function resolveRelativePath(rootData, currentPath, relativePath) {
+	const parentLevels = countParentLevels(relativePath);
+	const fieldPath = getPathAfterParents(relativePath);
+	if (!currentPath) return getValueByPath(rootData, fieldPath);
+	const pathSegments = parseCurrentPath(currentPath);
+	const targetLevel = pathSegments.length - parentLevels;
+	if (targetLevel <= 0) return getValueByPath(rootData, fieldPath);
+	const basePath = pathSegments.slice(0, targetLevel).join(".");
+	return getValueByPath(rootData, basePath ? `${basePath}.${fieldPath}` : fieldPath);
+}
+function extractRelativeBase(relativePath) {
+	const pathAfterParents = getPathAfterParents(relativePath);
+	const baseField = extractRootField(pathAfterParents);
+	return relativePath.slice(0, relativePath.length - pathAfterParents.length) + baseField;
+}
+function buildArrayContextTokens(arrayContext) {
+	if (!arrayContext || arrayContext.levels.length === 0) return {};
+	const tokens = {};
+	const levels = arrayContext.levels;
+	const buildLevelTokens = (level, prefix) => {
+		tokens[`${prefix}index`] = level.index;
+		tokens[`${prefix}length`] = level.length;
+		tokens[`${prefix}first`] = level.index === 0;
+		tokens[`${prefix}last`] = level.index === level.length - 1;
+	};
+	const buildNeighborTokens = (level, prefix) => {
+		tokens[`${prefix}prev`] = level.prev;
+		tokens[`${prefix}next`] = level.next;
+	};
+	if (levels[0]) {
+		buildLevelTokens(levels[0], "#");
+		buildNeighborTokens(levels[0], "@");
+	}
+	let parentPrefix = "#parent.";
+	let atParentPrefix = "@parent.";
+	for (let i = 1; i < levels.length; i++) {
+		const level = levels[i];
+		if (level) {
+			buildLevelTokens(level, parentPrefix);
+			buildNeighborTokens(level, atParentPrefix);
+		}
+		parentPrefix = "#parent." + parentPrefix.slice(1);
+		atParentPrefix = "@parent." + atParentPrefix.slice(1);
+	}
+	const rootLevel = levels.at(-1);
+	if (rootLevel) {
+		tokens["#root.index"] = rootLevel.index;
+		tokens["#root.length"] = rootLevel.length;
+		tokens["#root.first"] = rootLevel.index === 0;
+		tokens["#root.last"] = rootLevel.index === rootLevel.length - 1;
+		tokens["@root.prev"] = rootLevel.prev;
+		tokens["@root.next"] = rootLevel.next;
+	}
+	return tokens;
+}
+function buildPathReferences(rootData, dependencies, currentPath) {
+	const refs = {};
+	for (const dep of dependencies) if (dep.startsWith("/")) {
+		const rootField = extractRootField(dep.slice(1));
+		const contextKey = "/" + rootField;
+		if (!(contextKey in refs)) refs[contextKey] = getValueByPath(rootData, rootField);
+	} else if (dep.startsWith("../")) {
+		const contextKey = extractRelativeBase(dep);
+		if (!(contextKey in refs)) refs[contextKey] = resolveRelativePath(rootData, currentPath, contextKey);
+	}
+	return refs;
+}
+function evaluateWithContext(expression, options) {
+	const { rootData, itemData, currentPath, arrayContext } = options;
+	const trimmed = expression.trim();
+	if (!trimmed) throw new Error("Empty expression");
+	const pathRefs = buildPathReferences(rootData, parseFormula(trimmed).dependencies, currentPath);
+	const arrayTokens = buildArrayContextTokens(arrayContext);
+	return evaluate(trimmed, {
+		...rootData,
+		...itemData,
+		...pathRefs,
+		...arrayTokens
+	});
+}
+const ARITHMETIC_OPS = new Set([
+	"+",
+	"-",
+	"*",
+	"/",
+	"%"
+]);
+const COMPARISON_OPS = new Set([
+	"<",
+	">",
+	"<=",
+	">=",
+	"==",
+	"!="
+]);
+const LOGICAL_OPS = new Set([
+	"&&",
+	"||",
+	"!"
+]);
+const NUMERIC_FUNCTIONS = new Set([
+	"round",
+	"floor",
+	"ceil",
+	"abs",
+	"sqrt",
+	"pow",
+	"min",
+	"max",
+	"log",
+	"log10",
+	"exp",
+	"sign",
+	"sum",
+	"avg",
+	"count",
+	"tonumber",
+	"length"
+]);
+const STRING_FUNCTIONS = new Set([
+	"concat",
+	"upper",
+	"lower",
+	"trim",
+	"left",
+	"right",
+	"replace",
+	"tostring",
+	"join"
+]);
+const BOOLEAN_FUNCTIONS = new Set([
+	"and",
+	"or",
+	"not",
+	"contains",
+	"startswith",
+	"endswith",
+	"isnull",
+	"toboolean",
+	"includes"
+]);
+function getFieldType(path, fieldTypes) {
+	const schemaType = fieldTypes[path.split(".")[0]?.split("[")[0] || path];
+	if (schemaType === "number") return "number";
+	if (schemaType === "string") return "string";
+	if (schemaType === "boolean") return "boolean";
+	return "unknown";
+}
+function inferLiteralType(node) {
+	switch (node.type) {
+		case "NumberLiteral": return "number";
+		case "BooleanLiteral": return "boolean";
+		case "StringLiteral": return "string";
+		case "NullLiteral": return "unknown";
+		default: return null;
+	}
+}
+function inferBinaryOpType(node, fieldTypes) {
+	const { op } = node;
+	if (op === "+") {
+		const leftType = inferTypeFromAST(node.left, fieldTypes);
+		const rightType = inferTypeFromAST(node.right, fieldTypes);
+		if (leftType === "string" || rightType === "string") return "string";
+		if (leftType === "unknown" || rightType === "unknown") return "unknown";
+		return "number";
+	}
+	if (ARITHMETIC_OPS.has(op)) return "number";
+	if (COMPARISON_OPS.has(op)) return "boolean";
+	if (LOGICAL_OPS.has(op)) return "boolean";
+	return "unknown";
+}
+function inferCallExpressionType(node, fieldTypes) {
+	const funcName = node.callee.type === "Identifier" ? node.callee.name.toLowerCase() : "";
+	if (NUMERIC_FUNCTIONS.has(funcName)) return "number";
+	if (STRING_FUNCTIONS.has(funcName)) return "string";
+	if (BOOLEAN_FUNCTIONS.has(funcName)) return "boolean";
+	if (funcName === "if" && node.arguments.length >= 3) {
+		const thenArg = node.arguments[1];
+		const elseArg = node.arguments[2];
+		if (thenArg && elseArg) {
+			const thenType = inferTypeFromAST(thenArg, fieldTypes);
+			if (thenType === inferTypeFromAST(elseArg, fieldTypes)) return thenType;
+		}
+	}
+	return "unknown";
+}
+function inferTypeFromAST(node, fieldTypes) {
+	const literalType = inferLiteralType(node);
+	if (literalType !== null) return literalType;
+	switch (node.type) {
+		case "Identifier": return getFieldType(node.name, fieldTypes);
+		case "RootPath":
+		case "RelativePath":
+		case "ContextToken":
+		case "IndexExpression":
+		case "WildcardExpression": return "unknown";
+		case "MemberExpression": {
+			const objectType = inferTypeFromAST(node.object, fieldTypes);
+			if (objectType !== "unknown") return objectType;
+			if (node.object.type === "Identifier") return getFieldType(`${node.object.name}.${node.property}`, fieldTypes);
+			return "unknown";
+		}
+		case "BinaryOp": return inferBinaryOpType(node, fieldTypes);
+		case "UnaryOp":
+			if (node.op === "-") return "number";
+			if (node.op === "!") return "boolean";
+			return "unknown";
+		case "TernaryOp": {
+			const thenType = inferTypeFromAST(node.consequent, fieldTypes);
+			return thenType === inferTypeFromAST(node.alternate, fieldTypes) ? thenType : "unknown";
+		}
+		case "CallExpression": return inferCallExpressionType(node, fieldTypes);
+		default: return "unknown";
+	}
+}
+function inferFormulaType(expression, fieldTypes = {}) {
+	const trimmed = expression.trim();
+	if (!trimmed) return "unknown";
+	try {
+		const { ast } = parseFormula(trimmed);
+		return inferTypeFromAST(ast, fieldTypes);
+	} catch {
+		return "unknown";
+	}
+}
+
+//#endregion
+//#region src/ohm/core/serialize-ast.ts
+function escapeDoubleQuoted(value) {
+	let result = "";
+	for (const char of value) switch (char) {
+		case "\\":
+			result += String.raw`\\`;
+			break;
+		case "\"":
+			result += String.raw`\"`;
+			break;
+		case "\n":
+			result += String.raw`\n`;
+			break;
+		case "\r":
+			result += String.raw`\r`;
+			break;
+		case "	":
+			result += String.raw`\t`;
+			break;
+		default: result += char;
+	}
+	return result;
+}
+const PRECEDENCE = {
+	"||": 1,
+	"&&": 2,
+	"==": 3,
+	"!=": 3,
+	">": 4,
+	"<": 4,
+	">=": 4,
+	"<=": 4,
+	"+": 5,
+	"-": 5,
+	"*": 6,
+	"/": 6,
+	"%": 6
+};
+function serializeBinaryOp(node) {
+	const prec = PRECEDENCE[node.op] ?? 0;
+	const wrapLeft = (child) => {
+		const s = serializeNode(child);
+		if (child.type === "BinaryOp") {
+			if ((PRECEDENCE[child.op] ?? 0) < prec) return `(${s})`;
+		}
+		if (child.type === "TernaryOp") return `(${s})`;
+		return s;
+	};
+	const wrapRight = (child) => {
+		const s = serializeNode(child);
+		if (child.type === "BinaryOp") {
+			if ((PRECEDENCE[child.op] ?? 0) <= prec) return `(${s})`;
+		}
+		if (child.type === "TernaryOp") return `(${s})`;
+		return s;
+	};
+	return `${wrapLeft(node.left)} ${node.op} ${wrapRight(node.right)}`;
+}
+function serializeNode(node) {
+	switch (node.type) {
+		case "NumberLiteral": return String(node.value);
+		case "StringLiteral": return `"${escapeDoubleQuoted(node.value)}"`;
+		case "BooleanLiteral": return String(node.value);
+		case "NullLiteral": return "null";
+		case "Identifier": return node.name;
+		case "BracketedIdentifier": return `["${escapeDoubleQuoted(node.name)}"]`;
+		case "RootPath": return node.path;
+		case "RelativePath": return node.path;
+		case "ContextToken": return node.name;
+		case "BinaryOp": return serializeBinaryOp(node);
+		case "UnaryOp": return `${node.op}${serializeUnaryArgument(node)}`;
+		case "TernaryOp": return `${serializeTernaryCondition(node.condition)} ? ${serializeNode(node.consequent)} : ${serializeNode(node.alternate)}`;
+		case "CallExpression": return `${serializeNode(node.callee)}(${node.arguments.map(serializeNode).join(", ")})`;
+		case "MemberExpression": return `${serializePostfixObject(node.object)}.${node.property}`;
+		case "BracketedMemberExpression": return `${serializePostfixObject(node.object)}["${escapeDoubleQuoted(node.property)}"]`;
+		case "IndexExpression": return `${serializePostfixObject(node.object)}[${serializeNode(node.index)}]`;
+		case "WildcardExpression": return `${serializePostfixObject(node.object)}[*]`;
+	}
+}
+function serializeUnaryArgument(node) {
+	const s = serializeNode(node.argument);
+	if (node.argument.type === "BinaryOp" || node.argument.type === "TernaryOp") return `(${s})`;
+	return s;
+}
+function serializeTernaryCondition(node) {
+	const s = serializeNode(node);
+	if (node.type === "TernaryOp") return `(${s})`;
+	return s;
+}
+function serializePostfixObject(node) {
+	const s = serializeNode(node);
+	if (node.type === "BinaryOp" || node.type === "TernaryOp" || node.type === "UnaryOp") return `(${s})`;
+	return s;
+}
+function serializeAst(ast) {
+	return serializeNode(ast);
+}
+
+//#endregion
+//#region src/ohm/core/replace-dependencies.ts
+function collectDependencyPath(node) {
+	switch (node.type) {
+		case "Identifier": return node.name;
+		case "BracketedIdentifier": return `["${node.name}"]`;
+		case "RootPath": return node.path;
+		case "RelativePath": return node.path;
+		case "MemberExpression": {
+			const objPath = collectDependencyPath(node.object);
+			if (objPath === null) return null;
+			return `${objPath}.${node.property}`;
+		}
+		case "BracketedMemberExpression": {
+			const objPath = collectDependencyPath(node.object);
+			if (objPath === null) return null;
+			const quote = "\"";
+			return `${objPath}[${quote}${node.property}${quote}]`;
+		}
+		case "IndexExpression": {
+			const objPath = collectDependencyPath(node.object);
+			if (objPath === null) return null;
+			const numericIndex = getNumericIndex(node.index);
+			if (numericIndex !== null) return `${objPath}[${numericIndex}]`;
+			return null;
+		}
+		case "WildcardExpression": {
+			const objPath = collectDependencyPath(node.object);
+			if (objPath === null) return null;
+			return `${objPath}[*]`;
+		}
+		default: return null;
+	}
+}
+function getNumericIndex(node) {
+	if (node.type === "NumberLiteral") return node.value;
+	if (node.type === "UnaryOp" && node.op === "-" && node.argument.type === "NumberLiteral") return -node.argument.value;
+	return null;
+}
+function findMatch(node, replacements) {
+	const fullPath = collectDependencyPath(node);
+	if (fullPath !== null) {
+		const value = replacements[fullPath];
+		if (value !== void 0) return value;
+	}
+	return null;
+}
+function pathToAst(path) {
+	const { ast } = parseFormula(path);
+	return ast;
+}
+function replaceNode(node, replacements) {
+	const replacement = findMatch(node, replacements);
+	if (replacement !== null) return pathToAst(replacement);
+	switch (node.type) {
+		case "NumberLiteral":
+		case "StringLiteral":
+		case "BooleanLiteral":
+		case "NullLiteral":
+		case "Identifier":
+		case "BracketedIdentifier":
+		case "RootPath":
+		case "RelativePath":
+		case "ContextToken": return node;
+		case "BinaryOp": return {
+			...node,
+			left: replaceNode(node.left, replacements),
+			right: replaceNode(node.right, replacements)
+		};
+		case "UnaryOp": return {
+			...node,
+			argument: replaceNode(node.argument, replacements)
+		};
+		case "TernaryOp": return {
+			...node,
+			condition: replaceNode(node.condition, replacements),
+			consequent: replaceNode(node.consequent, replacements),
+			alternate: replaceNode(node.alternate, replacements)
+		};
+		case "CallExpression": {
+			const isSimpleFunctionCall = node.callee.type === "Identifier";
+			return {
+				...node,
+				callee: isSimpleFunctionCall ? node.callee : replaceNode(node.callee, replacements),
+				arguments: node.arguments.map((arg) => replaceNode(arg, replacements))
+			};
+		}
+		case "MemberExpression":
+		case "BracketedMemberExpression":
+		case "WildcardExpression": return {
+			...node,
+			object: replaceNode(node.object, replacements)
+		};
+		case "IndexExpression": return {
+			...node,
+			object: replaceNode(node.object, replacements),
+			index: replaceNode(node.index, replacements)
+		};
+	}
+}
+function replaceDependencies(ast, replacements) {
+	return replaceNode(ast, replacements);
+}
+
+//#endregion
+//#region src/parse-formula.ts
+/**
+* Parse a formula expression string
+*
+* @param expression - Formula expression string
+* @returns Parsed expression with dependencies and version info
+*
+* @example
+* parseExpression('price * 1.1')
+* // { expression: 'price * 1.1', dependencies: ['price'], minVersion: '1.0', features: [] }
+*
+* parseExpression('stats.damage * multiplier')
+* // { expression: '...', dependencies: ['stats.damage', 'multiplier'], minVersion: '1.1', features: ['nested_path'] }
+*/
+function parseExpression(expression) {
+	const result = parseFormula(expression);
+	return {
+		expression,
+		dependencies: result.dependencies,
+		minVersion: result.minVersion,
+		features: result.features
+	};
+}
+
+//#endregion
+//#region src/validate-syntax.ts
+/**
+* Validate formula expression syntax
+*
+* @param expression - Formula expression string
+* @returns Validation result with error details if invalid
+*
+* @example
+* validateFormulaSyntax('price * 1.1')
+* // { isValid: true }
+*
+* validateFormulaSyntax('price * (1.1')
+* // { isValid: false, error: 'Unclosed (', position: 8 }
+*/
+function validateFormulaSyntax(expression) {
+	const result = validateSyntax(expression);
+	if (result.isValid) return { isValid: true };
+	return {
+		isValid: false,
+		error: result.error,
+		position: result.position
+	};
+}
+
+//#endregion
+export { evaluate as a, parseFormula as c, serializeAst as i, validateSyntax as l, parseExpression as n, evaluateWithContext as o, replaceDependencies as r, inferFormulaType as s, validateFormulaSyntax as t };
+//# sourceMappingURL=validate-syntax-CmqnFrsc.mjs.map