@samva/markup 0.1.0 → 0.1.2

package/dist/predicate-CvkzT-a2.js

@@ -0,0 +1,539 @@
+import { Result } from "effect";
+//#region src/limits.ts
+/** Hard ceilings shared by SML documents and standalone predicate parsing. */
+const SML_PARSER_LIMITS = {
+	maxCharacters: 5e5,
+	maxUtf8Bytes: 1048576,
+	maxDepth: 64,
+	maxNodes: 25e3
+};
+//#endregion
+//#region src/predicate.ts
+/** Standalone predicates inherit the same source, nesting, and node ceilings as SML. */
+const PREDICATE_PARSER_LIMITS = SML_PARSER_LIMITS;
+const CHAR_TAB = 9;
+const CHAR_LINE_FEED = 10;
+const CHAR_CARRIAGE_RETURN = 13;
+const CHAR_SPACE = 32;
+const CHAR_BANG = 33;
+const CHAR_SINGLE_QUOTE = 39;
+const CHAR_OPEN_PAREN = 40;
+const CHAR_CLOSE_PAREN = 41;
+const CHAR_MINUS = 45;
+const CHAR_DOT = 46;
+const CHAR_LESS_THAN = 60;
+const CHAR_EQUALS = 61;
+const CHAR_GREATER_THAN = 62;
+const CHAR_UNDERSCORE = 95;
+const CHAR_0 = 48;
+const CHAR_9 = 57;
+const CHAR_UPPER_A = 65;
+const CHAR_UPPER_Z = 90;
+const CHAR_LOWER_A = 97;
+const CHAR_LOWER_Z = 122;
+const isWhitespace = (code) => code === CHAR_SPACE || code === CHAR_TAB || code === CHAR_LINE_FEED || code === CHAR_CARRIAGE_RETURN;
+const isDigit = (code) => code >= CHAR_0 && code <= CHAR_9;
+const isLetter = (code) => code >= CHAR_UPPER_A && code <= CHAR_UPPER_Z || code >= CHAR_LOWER_A && code <= CHAR_LOWER_Z;
+const isNameStart = (code) => isLetter(code) || code === CHAR_UNDERSCORE;
+const isNameChar = (code) => isNameStart(code) || isDigit(code);
+const KEYWORDS = [
+	"and",
+	"or",
+	"not"
+];
+const isKeyword = (text) => KEYWORDS.includes(text);
+const tokenize = (source, baseOffset) => {
+	const tokens = [];
+	let index = 0;
+	const length = source.length;
+	const failAt = (code, message, start, end) => Result.fail({ diagnostic: {
+		code,
+		message,
+		span: {
+			start: baseOffset + start,
+			end: baseOffset + end
+		}
+	} });
+	while (index < length) {
+		const code = source.charCodeAt(index);
+		if (isWhitespace(code)) {
+			index++;
+			continue;
+		}
+		const start = index;
+		if (code === CHAR_OPEN_PAREN) {
+			index++;
+			tokens.push({
+				kind: "lparen",
+				text: "(",
+				span: {
+					start: baseOffset + start,
+					end: baseOffset + index
+				}
+			});
+			continue;
+		}
+		if (code === CHAR_CLOSE_PAREN) {
+			index++;
+			tokens.push({
+				kind: "rparen",
+				text: ")",
+				span: {
+					start: baseOffset + start,
+					end: baseOffset + index
+				}
+			});
+			continue;
+		}
+		if (code === CHAR_EQUALS || code === CHAR_BANG) {
+			if (source.charCodeAt(index + 1) === CHAR_EQUALS) {
+				index += 2;
+				tokens.push({
+					kind: "op",
+					text: code === CHAR_EQUALS ? "==" : "!=",
+					span: {
+						start: baseOffset + start,
+						end: baseOffset + index
+					}
+				});
+				continue;
+			}
+			return failAt("predicate-invalid-operator", `unexpected ${String.fromCharCode(code)} — ${code === CHAR_EQUALS ? "write == to compare" : "write != to compare"}`, start, start + 1);
+		}
+		if (code === CHAR_GREATER_THAN || code === CHAR_LESS_THAN) {
+			index++;
+			if (source.charCodeAt(index) === CHAR_EQUALS) index++;
+			tokens.push({
+				kind: "op",
+				text: source.slice(start, index),
+				span: {
+					start: baseOffset + start,
+					end: baseOffset + index
+				}
+			});
+			continue;
+		}
+		if (code === CHAR_SINGLE_QUOTE) {
+			index++;
+			const contentStart = index;
+			while (index < length && source.charCodeAt(index) !== CHAR_SINGLE_QUOTE) index++;
+			if (index >= length) return failAt("predicate-unterminated-string", "unterminated string — add a closing '", start, length);
+			const value = source.slice(contentStart, index);
+			index++;
+			if (value.includes("--")) return failAt("predicate-string-double-dash", "string literals cannot contain -- (predicates are embedded in HTML comment markers)", start, index);
+			tokens.push({
+				kind: "string",
+				text: source.slice(start, index),
+				string: value,
+				span: {
+					start: baseOffset + start,
+					end: baseOffset + index
+				}
+			});
+			continue;
+		}
+		if (isDigit(code) || code === CHAR_MINUS && isDigit(source.charCodeAt(index + 1))) {
+			index++;
+			while (index < length && isDigit(source.charCodeAt(index))) index++;
+			if (source.charCodeAt(index) === CHAR_DOT && isDigit(source.charCodeAt(index + 1))) {
+				index++;
+				while (index < length && isDigit(source.charCodeAt(index))) index++;
+			}
+			tokens.push({
+				kind: "number",
+				text: source.slice(start, index),
+				number: Number.parseFloat(source.slice(start, index)),
+				span: {
+					start: baseOffset + start,
+					end: baseOffset + index
+				}
+			});
+			continue;
+		}
+		if (isNameStart(code)) {
+			index++;
+			while (index < length && isNameChar(source.charCodeAt(index))) index++;
+			if (source.charCodeAt(index) === CHAR_DOT) return failAt("predicate-path-not-supported", `unexpected . after "${source.slice(start, index)}" — predicates use flat variable names, not paths`, start, index + 1);
+			tokens.push({
+				kind: "name",
+				text: source.slice(start, index),
+				span: {
+					start: baseOffset + start,
+					end: baseOffset + index
+				}
+			});
+			continue;
+		}
+		if (code === CHAR_DOT) return failAt("predicate-path-not-supported", "unexpected . — predicates use flat variable names, not paths", start, start + 1);
+		return failAt("predicate-unexpected-character", `unexpected character ${JSON.stringify(String.fromCharCode(code))} in predicate`, start, start + 1);
+	}
+	tokens.push({
+		kind: "eof",
+		text: "",
+		span: {
+			start: baseOffset + length,
+			end: baseOffset + length
+		}
+	});
+	return Result.succeed(tokens);
+};
+const COMPARISON_OPS = [
+	"==",
+	"!=",
+	">",
+	">=",
+	"<",
+	"<="
+];
+/**
+* Parses a predicate. `baseOffset` is the absolute source offset of the
+* predicate's first character (an <If> test attribute passes valueSpan.start),
+* so diagnostic and node spans point into the containing document.
+*/
+const parsePredicate = (source, baseOffset = 0) => {
+	if (source.length > SML_PARSER_LIMITS.maxCharacters) return Result.fail([{
+		code: "predicate-character-limit",
+		message: `predicate exceeds the ${SML_PARSER_LIMITS.maxCharacters} character limit`,
+		span: {
+			start: baseOffset,
+			end: baseOffset + source.length
+		}
+	}]);
+	if (new TextEncoder().encode(source).byteLength > SML_PARSER_LIMITS.maxUtf8Bytes) return Result.fail([{
+		code: "predicate-byte-limit",
+		message: `predicate exceeds the ${SML_PARSER_LIMITS.maxUtf8Bytes} byte UTF-8 limit`,
+		span: {
+			start: baseOffset,
+			end: baseOffset + source.length
+		}
+	}]);
+	const lexed = tokenize(source, baseOffset);
+	if (Result.isFailure(lexed)) return Result.fail([lexed.failure.diagnostic]);
+	const tokens = lexed.success;
+	let index = 0;
+	let diagnostic;
+	let nodeCount = 0;
+	const fail = (code, message, span) => {
+		diagnostic ??= {
+			code,
+			message,
+			span
+		};
+		return null;
+	};
+	const peek = () => tokens[index];
+	const advance = () => tokens[index++];
+	const isKeywordToken = (token, keyword) => token.kind === "name" && token.text === keyword;
+	const countNode = (node) => {
+		nodeCount += 1;
+		return nodeCount > SML_PARSER_LIMITS.maxNodes ? fail("predicate-node-limit", `predicate exceeds the ${SML_PARSER_LIMITS.maxNodes} node limit`, node.span) : node;
+	};
+	const parsePrimary = (depth) => {
+		const token = advance();
+		if (token.kind === "lparen") {
+			if (depth >= SML_PARSER_LIMITS.maxDepth) return fail("predicate-depth-limit", `predicate nesting exceeds the maximum depth of ${SML_PARSER_LIMITS.maxDepth}`, token.span);
+			const inner = parseOr(depth + 1);
+			if (inner === null) return null;
+			const close = advance();
+			if (close.kind !== "rparen") return fail("predicate-missing-paren", "missing ) — close the group", close.span);
+			return inner;
+		}
+		if (token.kind === "name") {
+			if (isKeyword(token.text)) return fail("predicate-unexpected-token", `unexpected "${token.text}" — expected a variable name, comparison, or ( group )`, token.span);
+			const opToken = peek();
+			if (opToken.kind !== "op") return countNode({
+				kind: "name",
+				name: token.text,
+				span: token.span
+			});
+			advance();
+			const op = COMPARISON_OPS.find((candidate) => candidate === opToken.text);
+			if (op === void 0) return fail("predicate-invalid-operator", `unknown operator ${opToken.text} — use ==, !=, >, >=, <, or <=`, opToken.span);
+			const literalToken = advance();
+			if (literalToken.kind === "string") return countNode({
+				kind: "comparison",
+				name: token.text,
+				op,
+				literal: {
+					kind: "string",
+					value: literalToken.string
+				},
+				span: {
+					start: token.span.start,
+					end: literalToken.span.end
+				}
+			});
+			if (literalToken.kind === "number") return countNode({
+				kind: "comparison",
+				name: token.text,
+				op,
+				literal: {
+					kind: "number",
+					value: literalToken.number
+				},
+				span: {
+					start: token.span.start,
+					end: literalToken.span.end
+				}
+			});
+			return fail("predicate-expected-literal", `expected a literal after ${op} — write ${token.text} ${op} 'value' or ${token.text} ${op} 5`, literalToken.span);
+		}
+		if (token.kind === "eof") return fail("predicate-unexpected-end", "unexpected end of predicate — expected a variable name, comparison, or ( group )", token.span);
+		return fail("predicate-unexpected-token", `unexpected ${token.text} — comparisons put the variable first: name == 'value'`, token.span);
+	};
+	const parseUnary = (depth) => {
+		const token = peek();
+		if (isKeywordToken(token, "not")) {
+			advance();
+			const operand = parsePrimary(depth);
+			if (operand === null) return null;
+			return countNode({
+				kind: "not",
+				operand,
+				span: {
+					start: token.span.start,
+					end: operand.span.end
+				}
+			});
+		}
+		return parsePrimary(depth);
+	};
+	const parseAnd = (depth) => {
+		let left = parseUnary(depth);
+		while (left !== null && isKeywordToken(peek(), "and")) {
+			advance();
+			const right = parseUnary(depth);
+			if (right === null) return null;
+			left = countNode({
+				kind: "and",
+				left,
+				right,
+				span: {
+					start: left.span.start,
+					end: right.span.end
+				}
+			});
+		}
+		return left;
+	};
+	const parseOr = (depth) => {
+		let left = parseAnd(depth);
+		while (left !== null && isKeywordToken(peek(), "or")) {
+			advance();
+			const right = parseAnd(depth);
+			if (right === null) return null;
+			left = countNode({
+				kind: "or",
+				left,
+				right,
+				span: {
+					start: left.span.start,
+					end: right.span.end
+				}
+			});
+		}
+		return left;
+	};
+	if (source.trim().length === 0) return Result.fail([{
+		code: "predicate-empty",
+		message: "empty predicate — write e.g. plan == 'pro'",
+		span: {
+			start: baseOffset,
+			end: baseOffset + source.length
+		}
+	}]);
+	const ast = parseOr(0);
+	if (ast !== null && diagnostic === void 0) {
+		const trailing = peek();
+		if (trailing.kind !== "eof") fail("predicate-trailing-input", `unexpected ${JSON.stringify(trailing.text)} after the predicate — join clauses with "and" or "or"`, trailing.span);
+	}
+	if (ast === null || diagnostic !== void 0) return Result.fail([diagnostic ?? {
+		code: "predicate-parse-failed",
+		message: "predicate parse failed",
+		span: {
+			start: baseOffset,
+			end: baseOffset + source.length
+		}
+	}]);
+	return Result.succeed(ast);
+};
+const toNumber = (value) => {
+	if (typeof value === "number") return value;
+	if (typeof value === "string" && value.trim() !== "") return Number(value);
+	return NaN;
+};
+const compareNumbers = (op, left, right) => {
+	switch (op) {
+		case "==": return left === right;
+		case "!=": return left !== right;
+		case ">": return left > right;
+		case ">=": return left >= right;
+		case "<": return left < right;
+		case "<=": return left <= right;
+	}
+};
+const evaluateComparison = (node, variables) => {
+	const value = variables[node.name];
+	if (value === void 0 || value === null) return false;
+	if (node.literal.kind === "number") {
+		const left = toNumber(value);
+		if (Number.isNaN(left)) return false;
+		return compareNumbers(node.op, left, node.literal.value);
+	}
+	if (node.op === "==" || node.op === "!=") {
+		if (typeof value !== "string") return false;
+		return node.op === "==" ? value === node.literal.value : value !== node.literal.value;
+	}
+	const left = toNumber(value);
+	const right = toNumber(node.literal.value);
+	if (Number.isNaN(left) || Number.isNaN(right)) return false;
+	return compareNumbers(node.op, left, right);
+};
+const evaluatePredicate = (ast, variables) => {
+	const tasks = [{
+		kind: "node",
+		node: ast
+	}];
+	const values = [];
+	while (tasks.length > 0) {
+		const task = tasks.pop();
+		if (task.kind === "not") {
+			values.push(!values.pop());
+			continue;
+		}
+		if (task.kind === "and" || task.kind === "or") {
+			const left = values.pop();
+			if (task.kind === "and" && !left || task.kind === "or" && left) values.push(left);
+			else tasks.push({
+				kind: "node",
+				node: task.right
+			});
+			continue;
+		}
+		const node = task.node;
+		switch (node.kind) {
+			case "or":
+			case "and":
+				tasks.push({
+					kind: node.kind,
+					right: node.right
+				}, {
+					kind: "node",
+					node: node.left
+				});
+				break;
+			case "not":
+				tasks.push({ kind: "not" }, {
+					kind: "node",
+					node: node.operand
+				});
+				break;
+			case "comparison":
+				values.push(evaluateComparison(node, variables));
+				break;
+			case "name": {
+				const value = variables[node.name];
+				values.push(value !== void 0 && value !== null && value !== "");
+				break;
+			}
+		}
+	}
+	return values[0];
+};
+const precedence = (node) => {
+	switch (node.kind) {
+		case "or": return 1;
+		case "and": return 2;
+		case "not": return 3;
+		case "comparison":
+		case "name": return 4;
+	}
+};
+const printLiteral = (literal) => literal.kind === "string" ? `'${literal.value}'` : String(literal.value);
+/** Canonical form: single space around operators/keywords, minimal parens. */
+const printPredicate = (ast) => {
+	const frames = [{
+		kind: "node",
+		node: ast,
+		minPrecedence: 0
+	}];
+	const output = [];
+	while (frames.length > 0) {
+		const frame = frames.pop();
+		if (frame.kind === "text") {
+			output.push(frame.value);
+			continue;
+		}
+		const { node, minPrecedence } = frame;
+		const wrapped = precedence(node) < minPrecedence;
+		if (wrapped) frames.push({
+			kind: "text",
+			value: ")"
+		});
+		switch (node.kind) {
+			case "or":
+			case "and": {
+				const operator = node.kind === "or" ? " or " : " and ";
+				const childPrecedence = node.kind === "or" ? 1 : 2;
+				frames.push({
+					kind: "node",
+					node: node.right,
+					minPrecedence: childPrecedence
+				}, {
+					kind: "text",
+					value: operator
+				}, {
+					kind: "node",
+					node: node.left,
+					minPrecedence: childPrecedence
+				});
+				break;
+			}
+			case "not":
+				frames.push({
+					kind: "node",
+					node: node.operand,
+					minPrecedence: 4
+				}, {
+					kind: "text",
+					value: "not "
+				});
+				break;
+			case "comparison":
+				frames.push({
+					kind: "text",
+					value: `${node.name} ${node.op} ${printLiteral(node.literal)}`
+				});
+				break;
+			case "name": frames.push({
+				kind: "text",
+				value: node.name
+			});
+		}
+		if (wrapped) output.push("(");
+	}
+	return output.join("");
+};
+const collectPredicateVariables = (ast) => {
+	const names = /* @__PURE__ */ new Set();
+	const pending = [ast];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		switch (node.kind) {
+			case "or":
+			case "and":
+				pending.push(node.right, node.left);
+				break;
+			case "not":
+				pending.push(node.operand);
+				break;
+			case "comparison":
+			case "name": names.add(node.name);
+		}
+	}
+	return names;
+};
+//#endregion
+export { printPredicate as a, parsePredicate as i, collectPredicateVariables as n, SML_PARSER_LIMITS as o, evaluatePredicate as r, PREDICATE_PARSER_LIMITS as t };
+
+//# sourceMappingURL=predicate-CvkzT-a2.js.map

package/dist/{predicate-DTtVtLK7.d.ts → predicate-G2SeSvoN.d.ts}

@@ -1,6 +1,13 @@
 import { s as Span, t as Diagnostic } from "./diagnostics-oveE-laV.js";
 import { Result } from "effect";
 //#region src/predicate.d.ts
+/** Standalone predicates inherit the same source, nesting, and node ceilings as SML. */
+declare const PREDICATE_PARSER_LIMITS: {
+  readonly maxCharacters: 500000;
+  readonly maxUtf8Bytes: number;
+  readonly maxDepth: 64;
+  readonly maxNodes: 25000;
+};
 type ComparisonOp = "==" | "!=" | ">" | ">=" | "<" | "<=";
 type PredicateLiteral = {
   readonly kind: "string";
@@ -45,5 +52,5 @@ declare const evaluatePredicate: (ast: PredicateAst, variables: Record<string, u
 declare const printPredicate: (ast: PredicateAst) => string;
 declare const collectPredicateVariables: (ast: PredicateAst) => Set<string>;
 //#endregion
-export { evaluatePredicate as a, collectPredicateVariables as i, PredicateAst as n, parsePredicate as o, PredicateLiteral as r, printPredicate as s, ComparisonOp as t };
-//# sourceMappingURL=predicate-DTtVtLK7.d.ts.map
+export { collectPredicateVariables as a, printPredicate as c, PredicateLiteral as i, PREDICATE_PARSER_LIMITS as n, evaluatePredicate as o, PredicateAst as r, parsePredicate as s, ComparisonOp as t };
+//# sourceMappingURL=predicate-G2SeSvoN.d.ts.map

package/dist/predicate.d.ts

@@ -1,2 +1,2 @@
-import { a as evaluatePredicate, i as collectPredicateVariables, n as PredicateAst, o as parsePredicate, r as PredicateLiteral, s as printPredicate, t as ComparisonOp } from "./predicate-DTtVtLK7.js";
-export { ComparisonOp, PredicateAst, PredicateLiteral, collectPredicateVariables, evaluatePredicate, parsePredicate, printPredicate };
+import { a as collectPredicateVariables, c as printPredicate, i as PredicateLiteral, n as PREDICATE_PARSER_LIMITS, o as evaluatePredicate, r as PredicateAst, s as parsePredicate, t as ComparisonOp } from "./predicate-G2SeSvoN.js";
+export { ComparisonOp, PREDICATE_PARSER_LIMITS, PredicateAst, PredicateLiteral, collectPredicateVariables, evaluatePredicate, parsePredicate, printPredicate };