@samva/markup 0.8.0 → 0.9.0

package/dist/predicate-BI6uRRM-.js

@@ -1,549 +0,0 @@
-import { Result } from "better-result";
-//#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.err({ 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++;
-			}
-			const raw = source.slice(start, index);
-			const value = Number.parseFloat(raw);
-			if (!Number.isFinite(value)) return failAt("predicate-number-out-of-range", "number literal is outside the finite numeric range", start, index);
-			tokens.push({
-				kind: "number",
-				text: raw,
-				number: value,
-				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.ok(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.err([{
-		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.err([{
-		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.isError(lexed)) return Result.err([lexed.error.diagnostic]);
-	const tokens = lexed.value;
-	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.err([{
-		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.err([diagnostic ?? {
-		code: "predicate-parse-failed",
-		message: "predicate parse failed",
-		span: {
-			start: baseOffset,
-			end: baseOffset + source.length
-		}
-	}]);
-	return Result.ok(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) => {
-	if (literal.kind === "number") {
-		if (Number.isFinite(literal.value)) return String(literal.value);
-		throw new TypeError(`Number ${String(literal.value)} cannot be represented in a predicate: number literals must be finite`);
-	}
-	if (literal.value.includes("'") || literal.value.includes("--")) throw new TypeError(`String ${JSON.stringify(literal.value)} cannot be represented in a predicate: string literals cannot contain ' or --`);
-	return `'${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-BI6uRRM-.js.map

package/dist/predicate-M-05Nd7R.d.ts

@@ -1,56 +0,0 @@
-import { a as Span, t as Diagnostic } from "./diagnostics-OcQKQYSY.js";
-import { Result } from "better-result";
-//#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";
-  readonly value: string;
-} | {
-  readonly kind: "number";
-  readonly value: number;
-};
-type PredicateAst = {
-  readonly kind: "or";
-  readonly left: PredicateAst;
-  readonly right: PredicateAst;
-  readonly span: Span;
-} | {
-  readonly kind: "and";
-  readonly left: PredicateAst;
-  readonly right: PredicateAst;
-  readonly span: Span;
-} | {
-  readonly kind: "not";
-  readonly operand: PredicateAst;
-  readonly span: Span;
-} | {
-  readonly kind: "comparison";
-  readonly name: string;
-  readonly op: ComparisonOp;
-  readonly literal: PredicateLiteral;
-  readonly span: Span;
-} | {
-  readonly kind: "name";
-  readonly name: string;
-  readonly span: Span;
-};
-/**
- * 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.
- */
-declare const parsePredicate: (source: string, baseOffset?: number) => Result<PredicateAst, ReadonlyArray<Diagnostic>>;
-declare const evaluatePredicate: (ast: PredicateAst, variables: Record<string, unknown>) => boolean;
-/** Canonical form: single space around operators/keywords, minimal parens. */
-declare const printPredicate: (ast: PredicateAst) => string;
-declare const collectPredicateVariables: (ast: PredicateAst) => Set<string>;
-//#endregion
-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-M-05Nd7R.d.ts.map

package/dist/predicate.d.ts

@@ -1,2 +0,0 @@
-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-M-05Nd7R.js";
-export { ComparisonOp, PREDICATE_PARSER_LIMITS, PredicateAst, PredicateLiteral, collectPredicateVariables, evaluatePredicate, parsePredicate, printPredicate };

package/dist/predicate.js

@@ -1,2 +0,0 @@
-import { a as printPredicate, i as parsePredicate, n as collectPredicateVariables, r as evaluatePredicate, t as PREDICATE_PARSER_LIMITS } from "./predicate-BI6uRRM-.js";
-export { PREDICATE_PARSER_LIMITS, collectPredicateVariables, evaluatePredicate, parsePredicate, printPredicate };

package/dist/printer.d.ts

@@ -1,6 +0,0 @@
-import { b as SmlDocument } from "./ast-BrDtApwS.js";
-//#region src/printer.d.ts
-declare const printSml: (document: SmlDocument) => string;
-//#endregion
-export { printSml };
-//# sourceMappingURL=printer.d.ts.map