@klarkxy/dsh-deep-view 0.0.0-stage → 0.2.0

package/lib/core2.js

@@ -0,0 +1,1079 @@
+//#region src/core/formula.js
+const FUNCTIONS = {
+	min: {
+		args: [1, Infinity],
+		run: (...values) => Math.min(...values.map(num))
+	},
+	max: {
+		args: [1, Infinity],
+		run: (...values) => Math.max(...values.map(num))
+	},
+	abs: {
+		args: [1, 1],
+		run: (value) => Math.abs(num(value))
+	},
+	floor: {
+		args: [1, 1],
+		run: (value) => Math.floor(num(value))
+	},
+	ceil: {
+		args: [1, 1],
+		run: (value) => Math.ceil(num(value))
+	},
+	sqrt: {
+		args: [1, 1],
+		run: (value) => Math.sqrt(num(value))
+	},
+	pow: {
+		args: [2, 2],
+		run: (base, power) => num(base) ** num(power)
+	},
+	round: {
+		args: [1, 2],
+		run: (value, digits = 0) => roundTo(num(value), digitsOf(digits))
+	},
+	clamp: {
+		args: [3, 3],
+		run: (value, low, high) => Math.min(Math.max(num(value), num(low)), num(high))
+	},
+	fixed: {
+		args: [1, 2],
+		run: (value, digits = 0) => roundTo(num(value), digitsOf(digits)).toFixed(digitsOf(digits))
+	},
+	format: {
+		args: [1, 2],
+		run: (value, digits = 0) => grouped(num(value), digitsOf(digits))
+	},
+	percent: {
+		args: [1, 2],
+		run: (value, digits = 0) => `${grouped(num(value) * 100, digitsOf(digits))}%`
+	}
+};
+const FORMULA_FUNCTIONS = Object.keys(FUNCTIONS);
+const CONSTANTS = /* @__PURE__ */ new Map([["true", true], ["false", false]]);
+const MAX_NESTING = 64;
+var FormulaError = class extends Error {};
+const fail = (message) => {
+	throw new FormulaError(message);
+};
+function num(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "boolean") return value ? 1 : 0;
+	const parsed = Number(value);
+	if (typeof value === "string" && value.trim() !== "" && !Number.isNaN(parsed)) return parsed;
+	return fail(`${JSON.stringify(value)} is not a number`);
+}
+const digitsOf = (digits) => {
+	const value = num(digits);
+	if (!Number.isInteger(value) || value < 0 || value > 10) fail("digits must be a whole number from 0 to 10");
+	return value;
+};
+const roundTo = (value, digits) => {
+	const scale = 10 ** digits;
+	return Math.round(value * scale) / scale;
+};
+function grouped(value, digits) {
+	if (!Number.isFinite(value)) return String(value);
+	const [whole, part] = Math.abs(roundTo(value, digits)).toFixed(digits).split(".");
+	return `${value < 0 && Number(whole + (part ?? "")) !== 0 ? "-" : ""}${whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",")}${part ? `.${part}` : ""}`;
+}
+const IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const isName = (value) => typeof value === "string" && IDENT.test(value);
+const OPERATORS = [
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"&&",
+	"||",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"<",
+	">",
+	"!",
+	"?",
+	":",
+	"(",
+	")",
+	","
+];
+function tokenize(source) {
+	const tokens = [];
+	let at = 0;
+	while (at < source.length) {
+		const char = source[at];
+		if (/\s/.test(char)) {
+			at += 1;
+			continue;
+		}
+		const number = /^(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/.exec(source.slice(at));
+		if (number) {
+			tokens.push({
+				kind: "number",
+				value: Number(number[0]),
+				at
+			});
+			at += number[0].length;
+			continue;
+		}
+		const name = /^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(at));
+		if (name) {
+			tokens.push({
+				kind: "name",
+				value: name[0],
+				at
+			});
+			at += name[0].length;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			let end = at + 1;
+			let text = "";
+			while (end < source.length && source[end] !== char) {
+				if (source[end] === "\\" && end + 1 < source.length) {
+					text += source[end + 1];
+					end += 2;
+					continue;
+				}
+				text += source[end];
+				end += 1;
+			}
+			if (end >= source.length) fail(`unclosed string at ${at + 1}`);
+			tokens.push({
+				kind: "string",
+				value: text,
+				at
+			});
+			at = end + 1;
+			continue;
+		}
+		const operator = OPERATORS.find((op) => source.startsWith(op, at));
+		if (operator === void 0) fail(`unexpected ${JSON.stringify(char)} at ${at + 1}`);
+		tokens.push({
+			kind: "op",
+			value: operator,
+			at
+		});
+		at += operator.length;
+	}
+	return tokens;
+}
+const BINARY = [
+	["||"],
+	["&&"],
+	["==", "!="],
+	[
+		"<",
+		"<=",
+		">",
+		">="
+	],
+	["+", "-"],
+	[
+		"*",
+		"/",
+		"%"
+	]
+];
+function parse(source) {
+	const tokens = tokenize(source);
+	let index = 0;
+	let depth = 0;
+	const peek = () => tokens[index];
+	const isOp = (value) => peek()?.kind === "op" && peek().value === value;
+	const expect = (value) => {
+		if (!isOp(value)) fail(peek() ? `expected "${value}" at ${peek().at + 1}` : `expected "${value}" at the end`);
+		index += 1;
+	};
+	const nest = (read) => {
+		depth += 1;
+		if (depth > MAX_NESTING) fail(`nested more than ${MAX_NESTING} levels`);
+		const node = read();
+		depth -= 1;
+		return node;
+	};
+	const ternary = () => nest(() => {
+		const test = binary(0);
+		if (!isOp("?")) return test;
+		index += 1;
+		const yes = ternary();
+		expect(":");
+		return {
+			type: "if",
+			test,
+			yes,
+			no: ternary()
+		};
+	});
+	const binary = (level) => {
+		if (level === BINARY.length) return unary();
+		let left = binary(level + 1);
+		while (peek()?.kind === "op" && BINARY[level].includes(peek().value)) {
+			const op = peek().value;
+			index += 1;
+			left = {
+				type: "binary",
+				op,
+				left,
+				right: binary(level + 1)
+			};
+		}
+		return left;
+	};
+	const unary = () => {
+		if (isOp("-") || isOp("!") || isOp("+")) {
+			const op = peek().value;
+			index += 1;
+			return nest(() => ({
+				type: "unary",
+				op,
+				value: unary()
+			}));
+		}
+		return primary();
+	};
+	const primary = () => {
+		const token = peek();
+		if (token === void 0) fail("the formula ends too early");
+		index += 1;
+		if (token.kind === "number" || token.kind === "string") return {
+			type: "value",
+			value: token.value
+		};
+		if (token.kind === "op" && token.value === "(") {
+			const inner = ternary();
+			expect(")");
+			return inner;
+		}
+		if (token.kind !== "name") fail(`unexpected "${token.value}" at ${token.at + 1}`);
+		if (!isOp("(")) return CONSTANTS.has(token.value) ? {
+			type: "value",
+			value: CONSTANTS.get(token.value)
+		} : {
+			type: "name",
+			name: token.value
+		};
+		const fn = Object.hasOwn(FUNCTIONS, token.value) ? FUNCTIONS[token.value] : void 0;
+		if (fn === void 0) fail(`unknown function "${token.value}"; allowed: ${FORMULA_FUNCTIONS.join(", ")}`);
+		index += 1;
+		const args = [];
+		if (!isOp(")")) {
+			args.push(ternary());
+			while (isOp(",")) {
+				index += 1;
+				args.push(ternary());
+			}
+		}
+		expect(")");
+		if (args.length < fn.args[0] || args.length > fn.args[1]) fail(`${token.value}() takes ${fn.args[0] === fn.args[1] ? fn.args[0] : fn.args[1] === Infinity ? `at least ${fn.args[0]}` : `${fn.args[0]} or ${fn.args[1]}`} argument${fn.args[1] === 1 ? "" : "s"}; got ${args.length}`);
+		return {
+			type: "call",
+			name: token.value,
+			args
+		};
+	};
+	if (tokens.length === 0) fail("the formula is empty");
+	const tree = ternary();
+	if (index < tokens.length) fail(`unexpected "${peek().value}" at ${peek().at + 1}`);
+	return tree;
+}
+function namesIn(node, found = /* @__PURE__ */ new Set()) {
+	if (node.type === "name") found.add(node.name);
+	else if (node.type === "unary") namesIn(node.value, found);
+	else if (node.type === "binary") {
+		namesIn(node.left, found);
+		namesIn(node.right, found);
+	} else if (node.type === "if") {
+		namesIn(node.test, found);
+		namesIn(node.yes, found);
+		namesIn(node.no, found);
+	} else if (node.type === "call") for (const arg of node.args) namesIn(arg, found);
+	return found;
+}
+function compileFormula(source) {
+	if (typeof source !== "string") return { error: "expected a formula string" };
+	try {
+		const tree = parse(source);
+		return {
+			tree,
+			names: [...namesIn(tree)]
+		};
+	} catch (error) {
+		if (error instanceof FormulaError) return { error: error.message };
+		throw error;
+	}
+}
+function run(node, lookup) {
+	switch (node.type) {
+		case "value": return node.value;
+		case "name": return lookup(node.name);
+		case "unary": {
+			const value = run(node.value, lookup);
+			if (node.op === "!") return !truthy(value);
+			return node.op === "-" ? -num(value) : num(value);
+		}
+		case "if": return truthy(run(node.test, lookup)) ? run(node.yes, lookup) : run(node.no, lookup);
+		case "call": return FUNCTIONS[node.name].run(...node.args.map((arg) => run(arg, lookup)));
+		default: return binary(node, lookup);
+	}
+}
+const truthy = (value) => typeof value === "string" ? value !== "" : Boolean(value);
+function binary(node, lookup) {
+	if (node.op === "&&") return truthy(run(node.left, lookup)) ? run(node.right, lookup) : false;
+	if (node.op === "||") {
+		const left = run(node.left, lookup);
+		return truthy(left) ? left : run(node.right, lookup);
+	}
+	const left = run(node.left, lookup);
+	const right = run(node.right, lookup);
+	switch (node.op) {
+		case "+": return typeof left === "string" || typeof right === "string" ? `${show(left)}${show(right)}` : num(left) + num(right);
+		case "-": return num(left) - num(right);
+		case "*": return num(left) * num(right);
+		case "/": return num(left) / num(right);
+		case "%": return num(left) % num(right);
+		case "==": return left === right;
+		case "!=": return left !== right;
+		case "<": return num(left) < num(right);
+		case "<=": return num(left) <= num(right);
+		case ">": return num(left) > num(right);
+		default: return num(left) >= num(right);
+	}
+}
+function show(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? String(Number(value.toPrecision(12))) : String(value);
+	return String(value);
+}
+function createScope(inputs, lets) {
+	const done = /* @__PURE__ */ new Map();
+	const busy = /* @__PURE__ */ new Set();
+	const lookup = (name) => {
+		if (inputs.has(name)) return inputs.get(name);
+		if (done.has(name)) return done.get(name);
+		const tree = lets.get(name);
+		if (tree === void 0) fail(`unknown name "${name}"`);
+		if (busy.has(name)) fail(`"${name}" refers to itself`);
+		busy.add(name);
+		try {
+			const value = run(tree, lookup);
+			done.set(name, value);
+			return value;
+		} finally {
+			busy.delete(name);
+		}
+	};
+	return lookup;
+}
+function evaluate(tree, lookup) {
+	try {
+		return { value: run(tree, lookup) };
+	} catch (error) {
+		if (error instanceof FormulaError) return { error: error.message };
+		if (error instanceof RangeError) return { error: "the formula is too deep to work out" };
+		throw error;
+	}
+}
+//#endregion
+//#region src/core/views.js
+const LAYOUT = ["stack", "row"];
+const DISPLAY = [
+	"text",
+	"metric",
+	"table",
+	"chart",
+	"progress",
+	"callout",
+	"sources"
+];
+const INPUT_TYPES = [
+	"slider",
+	"choice",
+	"toggle",
+	"number"
+];
+const ANSWERS = [
+	"options",
+	"confirm",
+	"form",
+	"submit"
+];
+const COMPONENTS = [
+	...LAYOUT,
+	...DISPLAY,
+	...INPUT_TYPES,
+	...ANSWERS
+];
+const TONES = [
+	"good",
+	"warn",
+	"bad"
+];
+const TEXT_TONES = ["muted"];
+const CALLOUT_TONES = [
+	"info",
+	"good",
+	"warn",
+	"bad"
+];
+const CHART_KINDS = [
+	"bar",
+	"hbar",
+	"line",
+	"area",
+	"donut"
+];
+const INTERACTIVE = new Set(ANSWERS);
+const INPUTS = new Set(INPUT_TYPES);
+const PROPS = {
+	stack: ["children", "let"],
+	row: ["children", "let"],
+	text: ["text", "tone"],
+	metric: [
+		"label",
+		"value",
+		"tone",
+		"caption"
+	],
+	table: ["columns", "rows"],
+	chart: [
+		"kind",
+		"categories",
+		"series",
+		"unit",
+		"caption"
+	],
+	progress: [
+		"label",
+		"percent",
+		"value",
+		"max",
+		"valueLabel",
+		"tone"
+	],
+	callout: ["text", "tone"],
+	sources: ["items"],
+	slider: [
+		"id",
+		"label",
+		"min",
+		"max",
+		"step",
+		"value",
+		"unit"
+	],
+	choice: [
+		"id",
+		"label",
+		"options",
+		"value"
+	],
+	toggle: [
+		"id",
+		"label",
+		"value"
+	],
+	number: [
+		"id",
+		"label",
+		"min",
+		"max",
+		"step",
+		"value",
+		"unit"
+	],
+	options: [
+		"id",
+		"options",
+		"multi"
+	],
+	confirm: [
+		"id",
+		"confirmLabel",
+		"cancelLabel"
+	],
+	form: [
+		"id",
+		"fields",
+		"submitLabel"
+	],
+	submit: ["id", "label"]
+};
+const MAX_DEPTH = 8;
+const MAX_NODES = 64;
+const MAX_CHILDREN = 16;
+const MAX_TEXT = 2e3;
+const MAX_CELL = 200;
+const MAX_COLUMNS = 8;
+const MAX_ROWS = 50;
+const MAX_OPTIONS = 8;
+const MAX_FIELDS = 6;
+const SUMMARY_PART = 40;
+const SUMMARY_COUNT = 8;
+const RESERVED = /* @__PURE__ */ new Set(["true", "false"]);
+const VIEW_BYTE_LIMIT = 8192;
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const quoted = (value) => JSON.stringify(value);
+const allowed = (list) => list.join(", ");
+const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isScalar = (value) => typeof value === "string" || typeof value === "boolean" || isNumber(value);
+const isFormula = (value) => isRecord(value) && Object.keys(value).length === 1 && Object.hasOwn(value, "=");
+function viewBytes(title, view) {
+	return new TextEncoder().encode(`${JSON.stringify(view) ?? ""}${title ?? ""}`).length;
+}
+const NUMERIC = [
+	"value",
+	"percent",
+	"min",
+	"max",
+	"step",
+	"height"
+];
+const numeric = (value) => typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value)) ? Number(value) : value;
+function normalizeView(value) {
+	if (Array.isArray(value)) return value.map(normalizeView);
+	if (!isRecord(value)) return value;
+	const keys = Object.keys(value);
+	if (keys.length === 1 && keys[0] === "item") {
+		const inner = normalizeView(value.item);
+		if (Array.isArray(inner)) return inner;
+	}
+	const out = {};
+	for (const key of keys) Object.defineProperty(out, key, {
+		value: normalizeView(value[key]),
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+	for (const field of NUMERIC) if (Object.hasOwn(out, field)) out[field] = numeric(out[field]);
+	if (Array.isArray(out.values)) out.values = out.values.map(numeric);
+	return out;
+}
+function validateView(view) {
+	const ctx = {
+		ids: /* @__PURE__ */ new Set(),
+		nodes: 0,
+		interactive: false,
+		inputs: /* @__PURE__ */ new Map(),
+		lets: /* @__PURE__ */ new Map(),
+		formulas: []
+	};
+	const error = checkNode(view, "view", 1, ctx) ?? checkFormulas(ctx);
+	return error === void 0 ? {
+		ok: true,
+		interactive: ctx.interactive
+	} : {
+		ok: false,
+		error
+	};
+}
+function checkShownView(title, sent) {
+	let bytes;
+	try {
+		bytes = viewBytes(title, sent);
+	} catch {
+		return { error: "The view is not JSON data." };
+	}
+	if (bytes > 8192) return { error: `The view is ${bytes} bytes; the limit is ${VIEW_BYTE_LIMIT}.` };
+	if (title !== void 0 && title !== null && typeof title !== "string") return { error: "title: expected a string" };
+	const named = String(title ?? "").trim();
+	const view = normalizeView(sent);
+	const checked = validateView(view);
+	if (!checked.ok) return { error: checked.error };
+	return {
+		title: named,
+		view,
+		interactive: checked.interactive
+	};
+}
+function checkNode(node, path, depth, ctx) {
+	if (!isRecord(node)) return `${path}: expected a component object`;
+	if (depth > MAX_DEPTH) return `${path}: ${depth} levels exceeds the limit of ${MAX_DEPTH}`;
+	ctx.nodes += 1;
+	if (ctx.nodes > MAX_NODES) return `${path}: ${ctx.nodes} components exceeds the limit of ${MAX_NODES}`;
+	const type = node.type;
+	if (!COMPONENTS.includes(type)) return `${path}.type: unknown component ${quoted(type)}; allowed: ${allowed(COMPONENTS)}`;
+	const props = PROPS[type];
+	for (const key of Object.keys(node)) {
+		if (key === "type" || props.includes(key)) continue;
+		return `${path}.${key}: unknown property ${quoted(key)}; allowed: ${allowed(props)}`;
+	}
+	if (INTERACTIVE.has(type)) ctx.interactive = true;
+	switch (type) {
+		case "stack":
+		case "row": return checkLayout(node, path, depth, ctx);
+		case "text": return checkText(node, path, ctx);
+		case "metric": return checkMetric(node, path, ctx);
+		case "table": return checkTable(node, path, ctx);
+		case "chart": return checkChart(node, path, ctx);
+		case "progress": return checkProgress(node, path, ctx);
+		case "callout": return checkCallout(node, path, ctx);
+		case "sources": return checkSources(node, path);
+		case "slider":
+		case "number": return checkNumberInput(node, path, ctx);
+		case "choice": return checkChoice(node, path, ctx);
+		case "toggle": return checkToggle(node, path, ctx);
+		case "options": return checkOptions(node, path, ctx);
+		case "confirm": return checkConfirm(node, path, ctx);
+		case "form": return checkForm(node, path, ctx);
+		default: return checkSubmit(node, path, ctx);
+	}
+}
+function checkLayout(node, path, depth, ctx) {
+	if (node.let !== void 0) {
+		if (depth !== 1) return `${path}.let: only the outermost component can define names`;
+		if (!isRecord(node.let)) return `${path}.let: expected an object of names to formulas`;
+		for (const [name, source] of Object.entries(node.let)) {
+			if (!isName(name) || RESERVED.has(name)) return `${path}.let.${name}: a name is letters, digits and _, and starts with a letter or _`;
+			if (typeof source !== "string") return `${path}.let.${name}: expected a formula string`;
+			ctx.lets.set(name, {
+				source,
+				path: `${path}.let.${name}`
+			});
+		}
+	}
+	if (!Array.isArray(node.children)) return `${path}.children: expected an array of 1 to ${MAX_CHILDREN} components`;
+	if (node.children.length < 1 || node.children.length > MAX_CHILDREN) return `${path}.children: expected 1 to ${MAX_CHILDREN} children; got ${node.children.length}`;
+	for (let index = 0; index < node.children.length; index += 1) {
+		const error = checkNode(node.children[index], `${path}.children[${index}]`, depth + 1, ctx);
+		if (error !== void 0) return error;
+	}
+}
+function checkValue(node, key, path, ctx, kind, { required = false, max = MAX_TEXT } = {}) {
+	const value = node[key];
+	const at = `${path}.${key}`;
+	if (value === void 0) return required ? `${at}: ${expected(kind)}` : void 0;
+	if (isFormula(value)) {
+		ctx.formulas.push({
+			source: value["="],
+			path: at,
+			kind
+		});
+		return;
+	}
+	if (kind === "number") return isNumber(value) ? void 0 : `${at}: ${expected(kind)}`;
+	if (Array.isArray(kind)) return kind.includes(value) ? void 0 : `${at}: unknown tone ${quoted(value)}; allowed: ${allowed(kind)}`;
+	if (kind === "string") {
+		if (typeof value !== "string") return `${at}: ${expected(kind)}`;
+		return value.length > max ? `${at}: ${value.length} characters exceeds the limit of ${max}` : void 0;
+	}
+	if (!isScalar(value)) return `${at}: ${expected(kind)}`;
+}
+const expected = (kind) => kind === "number" ? "expected a number" : kind === "string" ? "expected a string" : Array.isArray(kind) ? `expected one of ${allowed(kind)}` : "expected a string or a number";
+function checkText(node, path, ctx) {
+	return checkValue(node, "text", path, ctx, "string", { required: true }) ?? checkValue(node, "tone", path, ctx, TEXT_TONES);
+}
+function checkMetric(node, path, ctx) {
+	if (typeof node.label !== "string") return `${path}.label: expected a string`;
+	if (node.value === void 0) return `${path}.value: expected a string or a number`;
+	if (typeof node.value === "number" && !Number.isFinite(node.value)) return `${path}.value: expected a finite number`;
+	return checkValue(node, "value", path, ctx, "scalar") ?? checkValue(node, "tone", path, ctx, TONES) ?? checkValue(node, "caption", path, ctx, "string");
+}
+function checkTable(node, path, ctx) {
+	if (!Array.isArray(node.columns)) return `${path}.columns: expected an array of at most ${MAX_COLUMNS} columns`;
+	if (node.columns.length > MAX_COLUMNS) return `${path}.columns: ${node.columns.length} columns exceeds the limit of ${MAX_COLUMNS}`;
+	for (let index = 0; index < node.columns.length; index += 1) {
+		const column = node.columns[index];
+		const at = `${path}.columns[${index}]`;
+		if (!isRecord(column)) return `${at}: expected a column object`;
+		for (const key of Object.keys(column)) if (key !== "key" && key !== "label") return `${at}.${key}: unknown property ${quoted(key)}; allowed: key, label`;
+		if (typeof column.key !== "string" || column.key === "") return `${at}.key: expected a non-empty string`;
+		if (typeof column.label !== "string") return `${at}.label: expected a string`;
+	}
+	if (!Array.isArray(node.rows)) return `${path}.rows: expected an array of at most ${MAX_ROWS} rows`;
+	if (node.rows.length > MAX_ROWS) return `${path}.rows: ${node.rows.length} rows exceeds the limit of ${MAX_ROWS}`;
+	for (let row = 0; row < node.rows.length; row += 1) {
+		const cells = node.rows[row];
+		if (!Array.isArray(cells)) return `${path}.rows[${row}]: expected an array of cells`;
+		for (let column = 0; column < cells.length; column += 1) {
+			const at = `${path}.rows[${row}][${column}]`;
+			if (isFormula(cells[column])) {
+				ctx.formulas.push({
+					source: cells[column]["="],
+					path: at,
+					kind: "scalar"
+				});
+				continue;
+			}
+			const text = cellText(cells[column]);
+			if (text.length > MAX_CELL) return `${at}: ${text.length} characters exceeds the limit of ${MAX_CELL}`;
+		}
+	}
+}
+function checkChart(node, path, ctx) {
+	if (node.kind !== void 0 && !CHART_KINDS.includes(node.kind)) return `${path}.kind: unknown chart ${quoted(node.kind)}; allowed: ${allowed(CHART_KINDS)}`;
+	if (!Array.isArray(node.categories) || node.categories.length === 0) return `${path}.categories: expected a non-empty array of labels`;
+	for (let index = 0; index < node.categories.length; index += 1) {
+		const label = node.categories[index];
+		if (typeof label !== "string" && !isNumber(label)) return `${path}.categories[${index}]: expected a string`;
+	}
+	if (!Array.isArray(node.series) || node.series.length === 0) return `${path}.series: expected a non-empty array of { name?, values }`;
+	if (node.kind === "donut" && node.series.length > 1) return `${path}.series: a donut takes one series; got ${node.series.length}`;
+	for (let index = 0; index < node.series.length; index += 1) {
+		const series = node.series[index];
+		const at = `${path}.series[${index}]`;
+		if (!isRecord(series)) return `${at}: expected a series object`;
+		for (const key of Object.keys(series)) if (key !== "name" && key !== "values") return `${at}.${key}: unknown property ${quoted(key)}; allowed: name, values`;
+		if (series.name !== void 0 && typeof series.name !== "string") return `${at}.name: expected a string`;
+		if (!Array.isArray(series.values)) return `${at}.values: expected an array of numbers`;
+		if (series.values.length !== node.categories.length) return `${at}.values: ${series.values.length} values for ${node.categories.length} categories`;
+		for (let item = 0; item < series.values.length; item += 1) {
+			const value = series.values[item];
+			if (isFormula(value)) ctx.formulas.push({
+				source: value["="],
+				path: `${at}.values[${item}]`,
+				kind: "number"
+			});
+			else if (!isNumber(value)) return `${at}.values[${item}]: expected a number`;
+		}
+	}
+	if (node.unit !== void 0 && typeof node.unit !== "string") return `${path}.unit: expected a string`;
+	if (node.caption !== void 0 && typeof node.caption !== "string") return `${path}.caption: expected a string`;
+}
+function checkProgress(node, path, ctx) {
+	if (node.label !== void 0 && typeof node.label !== "string") return `${path}.label: expected a string`;
+	if (node.percent === void 0 === (node.value === void 0)) return `${path}: give percent (0 to 100), or value with max`;
+	if (node.percent !== void 0 && !isFormula(node.percent)) {
+		if (typeof node.percent !== "number" || !Number.isFinite(node.percent) || node.percent < 0 || node.percent > 100) return `${path}.percent: expected a number from 0 to 100`;
+	}
+	if (node.value !== void 0 && node.max === void 0) return `${path}.max: expected a number with value`;
+	if (node.value === void 0 && node.max !== void 0) return `${path}.value: expected a number with max`;
+	return checkValue(node, "percent", path, ctx, "number") ?? checkValue(node, "value", path, ctx, "number") ?? checkValue(node, "max", path, ctx, "number") ?? checkValue(node, "valueLabel", path, ctx, "scalar") ?? checkValue(node, "tone", path, ctx, TONES);
+}
+function checkCallout(node, path, ctx) {
+	return checkValue(node, "text", path, ctx, "string", { required: true }) ?? checkValue(node, "tone", path, ctx, CALLOUT_TONES);
+}
+function checkSources(node, path) {
+	if (!Array.isArray(node.items) || node.items.length === 0) return `${path}.items: expected a non-empty array of { label, url }`;
+	for (let index = 0; index < node.items.length; index += 1) {
+		const item = node.items[index];
+		const at = `${path}.items[${index}]`;
+		if (!isRecord(item)) return `${at}: expected a { label, url } object`;
+		for (const key of Object.keys(item)) if (key !== "label" && key !== "url") return `${at}.${key}: unknown property ${quoted(key)}; allowed: label, url`;
+		if (typeof item.label !== "string" || item.label.trim() === "") return `${at}.label: expected a non-empty string`;
+		if (typeof item.url !== "string" || !/^https?:\/\/[^\s]+$/i.test(item.url)) return `${at}.url: expected an http(s) address`;
+	}
+}
+function checkInputId(node, path, ctx) {
+	if (!isName(node.id) || RESERVED.has(node.id)) return `${path}.id: an input id is letters, digits and _, and starts with a letter or _, so formulas can use it`;
+	if (ctx.ids.has(node.id)) return `${path}.id: duplicate id ${quoted(node.id)}`;
+	ctx.ids.add(node.id);
+	if (typeof node.label !== "string") return `${path}.label: expected a string`;
+}
+function checkNumberInput(node, path, ctx) {
+	const idError = checkInputId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	for (const key of [
+		"min",
+		"max",
+		"step"
+	]) if (node[key] !== void 0 && !isNumber(node[key])) return `${path}.${key}: expected a number`;
+	if (node.type === "slider" && (node.min === void 0 || node.max === void 0)) return `${path}: a slider needs min and max`;
+	if (node.min !== void 0 && node.max !== void 0 && node.max <= node.min) return `${path}.max: expected more than min (${node.min})`;
+	if (node.step !== void 0 && node.step <= 0) return `${path}.step: expected more than 0`;
+	if (!isNumber(node.value)) return `${path}.value: expected a number`;
+	if (node.min !== void 0 && node.value < node.min || node.max !== void 0 && node.value > node.max) return `${path}.value: expected a number from ${node.min ?? "-∞"} to ${node.max ?? "∞"}`;
+	if (node.unit !== void 0 && typeof node.unit !== "string") return `${path}.unit: expected a string`;
+	ctx.inputs.set(node.id, node.value);
+}
+function checkChoice(node, path, ctx) {
+	const idError = checkInputId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (!Array.isArray(node.options) || node.options.length === 0) return `${path}.options: expected a non-empty array of { label, value }`;
+	const labels = /* @__PURE__ */ new Set();
+	const values = /* @__PURE__ */ new Set();
+	for (let index = 0; index < node.options.length; index += 1) {
+		const option = node.options[index];
+		const at = `${path}.options[${index}]`;
+		if (!isRecord(option)) return `${at}: expected a { label, value } object`;
+		for (const key of Object.keys(option)) if (key !== "label" && key !== "value") return `${at}.${key}: unknown property ${quoted(key)}; allowed: label, value`;
+		if (typeof option.label !== "string" || option.label.trim() === "") return `${at}.label: expected a non-empty string`;
+		if (labels.has(option.label)) return `${at}.label: duplicate label ${quoted(option.label)}`;
+		labels.add(option.label);
+		const value = option.value ?? option.label;
+		if (!isScalar(value)) return `${at}.value: expected a string, a number or true/false`;
+		if (values.has(value)) return `${at}.value: duplicate value ${quoted(value)}`;
+		values.add(value);
+	}
+	const chosen = node.value ?? choiceValue(node.options[0]);
+	if (!values.has(chosen)) return `${path}.value: expected one of the options' values`;
+	ctx.inputs.set(node.id, chosen);
+}
+function checkToggle(node, path, ctx) {
+	const idError = checkInputId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.value !== void 0 && typeof node.value !== "boolean") return `${path}.value: expected true or false`;
+	ctx.inputs.set(node.id, node.value === true);
+}
+function checkOptions(node, path, ctx) {
+	const idError = checkId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.multi !== void 0 && typeof node.multi !== "boolean") return `${path}.multi: expected a boolean`;
+	if (!Array.isArray(node.options)) return `${path}.options: expected an array of 1 to ${MAX_OPTIONS} options`;
+	if (node.options.length < 1 || node.options.length > MAX_OPTIONS) return `${path}.options: expected 1 to ${MAX_OPTIONS} options; got ${node.options.length}`;
+	const labels = /* @__PURE__ */ new Set();
+	for (let index = 0; index < node.options.length; index += 1) {
+		const option = node.options[index];
+		const at = `${path}.options[${index}]`;
+		if (!isRecord(option)) return `${at}: expected an option object`;
+		for (const key of Object.keys(option)) if (key !== "label" && key !== "description") return `${at}.${key}: unknown property ${quoted(key)}; allowed: label, description`;
+		if (typeof option.label !== "string" || option.label.trim() === "") return `${at}.label: expected a non-empty string`;
+		if (labels.has(option.label)) return `${at}.label: duplicate label ${quoted(option.label)}`;
+		labels.add(option.label);
+		if (option.description !== void 0 && typeof option.description !== "string") return `${at}.description: expected a string`;
+	}
+}
+function checkConfirm(node, path, ctx) {
+	const idError = checkId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.confirmLabel !== void 0 && typeof node.confirmLabel !== "string") return `${path}.confirmLabel: expected a string`;
+	if (node.cancelLabel !== void 0 && typeof node.cancelLabel !== "string") return `${path}.cancelLabel: expected a string`;
+}
+function checkForm(node, path, ctx) {
+	const idError = checkId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.submitLabel !== void 0 && typeof node.submitLabel !== "string") return `${path}.submitLabel: expected a string`;
+	if (!Array.isArray(node.fields)) return `${path}.fields: expected an array of at most ${MAX_FIELDS} fields`;
+	if (node.fields.length > MAX_FIELDS) return `${path}.fields: ${node.fields.length} fields exceeds the limit of ${MAX_FIELDS}`;
+	const seen = /* @__PURE__ */ new Set();
+	for (let index = 0; index < node.fields.length; index += 1) {
+		const field = node.fields[index];
+		const at = `${path}.fields[${index}]`;
+		if (!isRecord(field)) return `${at}: expected a field object`;
+		for (const key of Object.keys(field)) if (key !== "id" && key !== "label" && key !== "placeholder") return `${at}.${key}: unknown property ${quoted(key)}; allowed: id, label, placeholder`;
+		if (typeof field.id !== "string" || field.id === "") return `${at}.id: expected a non-empty string`;
+		if (field.id === "__proto__") return `${at}.id: "__proto__" cannot be an id`;
+		if (seen.has(field.id)) return `${at}.id: duplicate field id ${quoted(field.id)}`;
+		seen.add(field.id);
+		if (typeof field.label !== "string") return `${at}.label: expected a string`;
+		if (field.placeholder !== void 0 && typeof field.placeholder !== "string") return `${at}.placeholder: expected a string`;
+	}
+}
+function checkSubmit(node, path, ctx) {
+	const idError = checkId(node, path, ctx);
+	if (idError !== void 0) return idError;
+	if (node.label !== void 0 && typeof node.label !== "string") return `${path}.label: expected a string`;
+}
+function checkId(node, path, ctx) {
+	if (typeof node.id !== "string" || node.id === "") return `${path}.id: expected a non-empty string`;
+	if (node.id === "__proto__") return `${path}.id: "__proto__" cannot be an id`;
+	if (ctx.ids.has(node.id)) return `${path}.id: duplicate id ${quoted(node.id)}`;
+	ctx.ids.add(node.id);
+}
+function checkFormulas(ctx) {
+	const known = /* @__PURE__ */ new Set([...ctx.inputs.keys(), ...ctx.lets.keys()]);
+	const lets = /* @__PURE__ */ new Map();
+	for (const [name, entry] of ctx.lets) {
+		if (ctx.inputs.has(name)) return `${entry.path}: ${quoted(name)} is already an input id`;
+		const compiled = compileFormula(entry.source);
+		if (compiled.error !== void 0) return `${entry.path}: ${compiled.error}`;
+		const unknown = compiled.names.find((item) => !known.has(item));
+		if (unknown !== void 0) return `${entry.path}: unknown name ${quoted(unknown)}; known: ${allowed([...known]) || "(none)"}`;
+		lets.set(name, compiled.tree);
+	}
+	const lookup = createScope(ctx.inputs, lets);
+	for (const [name, entry] of ctx.lets) {
+		const result = evaluate(lets.get(name), lookup);
+		if (result.error !== void 0) return `${entry.path}: ${result.error}`;
+	}
+	for (const formula of ctx.formulas) {
+		const compiled = compileFormula(formula.source);
+		if (compiled.error !== void 0) return `${formula.path}: ${compiled.error}`;
+		const unknown = compiled.names.find((item) => !known.has(item));
+		if (unknown !== void 0) return `${formula.path}: unknown name ${quoted(unknown)}; known: ${allowed([...known]) || "(none)"}`;
+		const result = evaluate(compiled.tree, lookup);
+		if (result.error !== void 0) return `${formula.path}: ${result.error}`;
+		const problem = kindProblem(result.value, formula.kind);
+		if (problem !== void 0) return `${formula.path}: the formula gives ${quoted(result.value)}; ${problem}`;
+	}
+}
+function kindProblem(value, kind) {
+	if (kind === "number") return isNumber(value) ? void 0 : "expected a number";
+	if (Array.isArray(kind)) return kind.includes(value) ? void 0 : `expected one of ${allowed(kind)}`;
+	if (kind === "string") return isScalar(value) ? void 0 : "expected text";
+	return isScalar(value) ? void 0 : "expected a string or a number";
+}
+function cellText(value) {
+	if (typeof value === "string") return value;
+	const text = JSON.stringify(value);
+	return typeof text === "string" ? text : "";
+}
+const compiled = /* @__PURE__ */ new WeakMap();
+const treeOf = (formula) => {
+	let entry = compiled.get(formula);
+	if (entry === void 0) {
+		entry = compileFormula(formula["="]);
+		compiled.set(formula, entry);
+	}
+	return entry;
+};
+const choiceValue = (option) => option?.value ?? option?.label;
+function walk(node, visit) {
+	if (!isRecord(node)) return;
+	visit(node);
+	if (LAYOUT.includes(node.type) && Array.isArray(node.children)) for (const child of node.children) walk(child, visit);
+}
+function viewInputs(view) {
+	const found = [];
+	walk(view, (node) => {
+		if (INPUTS.has(node.type)) found.push(node);
+	});
+	return found;
+}
+function inputDefault(node) {
+	if (node.type === "toggle") return node.value === true;
+	if (node.type === "choice") return node.value ?? choiceValue(Array.isArray(node.options) ? node.options[0] : void 0);
+	return node.value;
+}
+const hasInputs = (view) => viewInputs(view).length > 0;
+function viewScope(view, values = {}) {
+	const inputs = /* @__PURE__ */ new Map();
+	for (const node of viewInputs(view)) inputs.set(node.id, Object.hasOwn(values, node.id) ? values[node.id] : inputDefault(node));
+	const lets = /* @__PURE__ */ new Map();
+	for (const [name, source] of Object.entries(isRecord(view?.let) ? view.let : {})) {
+		const entry = compileFormula(source);
+		if (entry.tree !== void 0) lets.set(name, entry.tree);
+	}
+	return createScope(inputs, lets);
+}
+function resolve(value, lookup, fallback = void 0) {
+	if (!isFormula(value)) return value;
+	const entry = treeOf(value);
+	if (entry.tree === void 0) return fallback;
+	const result = evaluate(entry.tree, lookup);
+	return result.error === void 0 ? result.value : fallback;
+}
+const asText = (value) => value === void 0 || value === null ? "" : show(value);
+function clip(text) {
+	const flat = String(text).replace(/\s+/g, " ").trim();
+	return flat.length <= SUMMARY_PART ? flat : flat.slice(0, SUMMARY_PART);
+}
+const choiceLabel = (node, value) => (Array.isArray(node.options) ? node.options : []).find((option) => choiceValue(option) === value)?.label ?? asText(value);
+function inputText(node, value) {
+	if (node.type === "toggle") return value === true ? "on" : "off";
+	if (node.type === "choice") return choiceLabel(node, value);
+	return `${asText(value)}${node.unit ? ` ${node.unit}` : ""}`;
+}
+function progressPercent(node, lookup) {
+	if (node.percent !== void 0) return Number(resolve(node.percent, lookup, 0));
+	const max = Number(resolve(node.max, lookup, 0));
+	return max > 0 ? Number(resolve(node.value, lookup, 0)) / max * 100 : 0;
+}
+function componentSummary(node, lookup) {
+	const value = (item) => asText(resolve(item, lookup, ""));
+	switch (node.type) {
+		case "text": return `text: ${value(node.text)}`;
+		case "metric": return `metric: ${node.label}=${value(node.value)}`;
+		case "table": return `table: ${(Array.isArray(node.columns) ? node.columns : []).map((column) => column?.label ?? column?.key ?? "").filter(Boolean).join("/")}`;
+		case "chart": {
+			const series = Array.isArray(node.series) ? node.series[0] : void 0;
+			const values = Array.isArray(series?.values) ? series.values : [];
+			const unit = node.unit ? ` ${node.unit}` : "";
+			return `chart: ${(Array.isArray(node.categories) ? node.categories : []).map((label, index) => `${label}=${value(values[index])}${unit}`).join(", ")}`;
+		}
+		case "progress": return `progress: ${node.label ? `${node.label} ` : ""}${Math.round(progressPercent(node, lookup))}%`;
+		case "callout": return `callout: ${value(node.text)}`;
+		case "sources": return `sources: ${(Array.isArray(node.items) ? node.items : []).map((item) => item?.label).filter(Boolean).join("/")}`;
+		case "slider":
+		case "number":
+		case "choice":
+		case "toggle": return `${node.type}: ${node.label}=${inputText(node, inputDefault(node))}`;
+		case "options": return `options: ${(Array.isArray(node.options) ? node.options : []).map((option) => option?.label).filter(Boolean).join("/")}`;
+		case "confirm": return "confirm";
+		case "form": return `form: ${(Array.isArray(node.fields) ? node.fields : []).map((field) => field?.label ?? field?.id).filter(Boolean).join("/")}`;
+		case "submit": return `submit: ${node.label ?? "Send"}`;
+		default: return;
+	}
+}
+function viewSummary(view) {
+	const parts = [];
+	const lookup = viewScope(view);
+	const visit = (node) => {
+		if (parts.length >= SUMMARY_COUNT || !isRecord(node)) return;
+		const line = componentSummary(node, lookup);
+		if (line !== void 0) parts.push(clip(line));
+		if (parts.length >= SUMMARY_COUNT || !LAYOUT.includes(node.type) || !Array.isArray(node.children)) return;
+		for (const child of node.children) visit(child);
+	};
+	visit(view);
+	return parts.join("; ");
+}
+function inputsSummary(view, inputs) {
+	if (!isRecord(inputs)) return "";
+	return viewInputs(view).filter((node) => Object.hasOwn(inputs, node.id)).map((node) => `${node.label || node.id}=${inputText(node, inputs[node.id])}`).join("; ");
+}
+function interactiveNodes(node, found = []) {
+	walk(node, (item) => {
+		if (INTERACTIVE.has(item.type)) found.push(item);
+	});
+	return found;
+}
+function validateViewAnswer(view, action, values) {
+	const nodes = interactiveNodes(view);
+	if (typeof action !== "string" || action === "") return { error: `action: expected an interactive component id; allowed: ${allowed(nodes.map((node) => node.id))}` };
+	const node = nodes.find((item) => item.id === action);
+	if (node === void 0) return { error: `action: no interactive component with id ${quoted(action)}; allowed: ${allowed(nodes.map((item) => item.id))}` };
+	if (!isRecord(values)) return { error: "values: expected an object" };
+	const inputs = validateInputs(view, values.inputs);
+	if (inputs.error !== void 0) return inputs;
+	const extra = inputs.inputs === void 0 ? {} : { inputs: inputs.inputs };
+	if (node.type === "submit") return { ...extra };
+	const own = node.type === "options" ? validateOptions(node, values) : node.type === "confirm" ? validateConfirm(values) : validateForm(node, values);
+	return own.error === void 0 ? {
+		...own,
+		...extra
+	} : own;
+}
+function validateInputs(view, sent) {
+	const nodes = viewInputs(view);
+	if (nodes.length === 0) return sent === void 0 ? {} : { error: "values.inputs: this view has no inputs" };
+	if (sent !== void 0 && !isRecord(sent)) return { error: "values.inputs: expected an object of input ids to values" };
+	const given = sent ?? {};
+	const ids = nodes.map((node) => node.id);
+	const unknown = Object.keys(given).find((key) => !ids.includes(key));
+	if (unknown !== void 0) return { error: `values.inputs.${unknown}: unknown input; allowed: ${allowed(ids)}` };
+	const inputs = {};
+	for (const node of nodes) {
+		const value = Object.hasOwn(given, node.id) ? given[node.id] : inputDefault(node);
+		const at = `values.inputs.${node.id}`;
+		if (node.type === "toggle" && typeof value !== "boolean") return { error: `${at}: expected true or false` };
+		if (node.type === "choice" && !(Array.isArray(node.options) ? node.options : []).some((option) => choiceValue(option) === value)) return { error: `${at}: expected one of the options' values` };
+		if (node.type === "slider" || node.type === "number") {
+			if (!isNumber(value)) return { error: `${at}: expected a number` };
+			if (node.min !== void 0 && value < node.min || node.max !== void 0 && value > node.max) return { error: `${at}: expected a number from ${node.min ?? "-∞"} to ${node.max ?? "∞"}` };
+		}
+		inputs[node.id] = value;
+	}
+	return { inputs };
+}
+function validateOptions(node, values) {
+	if (!Array.isArray(values.selected)) return { error: "values.selected: expected an array of option labels" };
+	const labels = new Set((node.options ?? []).map((option) => option?.label));
+	const picked = values.selected.filter((label) => typeof label === "string" && labels.has(label));
+	const selected = node.multi === true ? [...new Set(picked)] : picked.slice(0, 1);
+	if (selected.length === 0) return { error: "values.selected: select at least one option" };
+	return { selected };
+}
+function validateConfirm(values) {
+	if (typeof values.confirmed !== "boolean") return { error: "values.confirmed: expected a boolean" };
+	return { confirmed: values.confirmed };
+}
+function validateForm(node, values) {
+	if (!isRecord(values.fields)) return { error: "values.fields: expected an object of field ids to strings" };
+	const declared = (node.fields ?? []).map((field) => field?.id).filter((id) => typeof id === "string");
+	const allowedIds = new Set(declared);
+	const fields = {};
+	for (const [key, value] of Object.entries(values.fields)) {
+		if (!allowedIds.has(key)) return { error: `values.fields.${key}: unknown field; allowed: ${allowed(declared)}` };
+		if (typeof value !== "string") return { error: `values.fields.${key}: expected a string` };
+		if (value.length > MAX_TEXT) return { error: `values.fields.${key}: ${value.length} characters exceeds the limit of ${MAX_TEXT}` };
+		fields[key] = value;
+	}
+	return { fields };
+}
+//#endregion
+export { show as C, isName as S, viewSummary as _, choiceValue as a, createScope as b, inputsSummary as c, resolve as d, validateView as f, viewScope as g, viewInputs as h, checkShownView as i, isFormula as l, viewBytes as m, VIEW_BYTE_LIMIT as n, hasInputs as o, validateViewAnswer as p, asText as r, inputDefault as s, CHART_KINDS as t, normalizeView as u, FORMULA_FUNCTIONS as v, evaluate as x, compileFormula as y };
+
+//# sourceMappingURL=core2.js.map