@lernapps/app-templates 0.0.0-stage → 0.1.0

package/dist/assessment-By2GGTJC.mjs

@@ -0,0 +1,1696 @@
+import { i as inLanguage, l as textsIn, s as localeOf, t as escape } from "./html-mffkHGHh.mjs";
+import { S as shuffled, c as hash, m as parseNumber, u as isCorrect, y as random } from "./render-BJey0bwl.mjs";
+import { createStorage } from "@lernapps/tooling/storage";
+// runtime/explainer/fraction.ts
+const abs = (n) => n < 0n ? -n : n;
+function gcd(a, b) {
+	let x = abs(a);
+	let y = abs(b);
+	while (y !== 0n) [x, y] = [y, x % y];
+	return x;
+}
+var Fraction = class Fraction {
+	n;
+	d;
+	constructor(n, d) {
+		if (d === 0n) throw new RangeError("division by zero");
+		const sign = d < 0n ? -1n : 1n;
+		const g = gcd(n, d) || 1n;
+		this.n = sign * n / g;
+		this.d = sign * d / g;
+	}
+	static of(n, d = 1) {
+		return new Fraction(BigInt(n), BigInt(d));
+	}
+	/** A number as written: 0.1 is exactly 1/10. */
+	static from(value) {
+		if (!Number.isFinite(value)) throw new RangeError(`${value} is not a number`);
+		const text = String(value);
+		const match = /^(-?)(\d+)(?:\.(\d+))?(?:e([+-]\d+))?$/.exec(text);
+		if (match === null) throw new RangeError(`${text} is not a number`);
+		const [, sign = "", whole = "0", part = "", exponent = "0"] = match;
+		let n = BigInt(`${sign}${whole}${part}`);
+		let d = 10n ** BigInt(part.length);
+		const e = Number(exponent);
+		if (e > 0) n *= 10n ** BigInt(e);
+		else if (e < 0) d *= 10n ** BigInt(-e);
+		return new Fraction(n, d);
+	}
+	add(other) {
+		return new Fraction(this.n * other.d + other.n * this.d, this.d * other.d);
+	}
+	sub(other) {
+		return new Fraction(this.n * other.d - other.n * this.d, this.d * other.d);
+	}
+	mul(other) {
+		return new Fraction(this.n * other.n, this.d * other.d);
+	}
+	div(other) {
+		if (other.n === 0n) throw new RangeError("division by zero");
+		return new Fraction(this.n * other.d, this.d * other.n);
+	}
+	neg() {
+		return new Fraction(-this.n, this.d);
+	}
+	abs() {
+		return new Fraction(abs(this.n), this.d);
+	}
+	compare(other) {
+		const left = this.n * other.d;
+		const right = other.n * this.d;
+		return left < right ? -1 : left > right ? 1 : 0;
+	}
+	equals(other) {
+		return this.n === other.n && this.d === other.d;
+	}
+	isInteger() {
+		return this.d === 1n;
+	}
+	/** Rounded to `places` decimals, half away from zero. */
+	round(places) {
+		const scale = 10n ** BigInt(Math.max(0, places));
+		const scaled = abs(this.n) * scale;
+		const q = scaled / this.d;
+		const rounded = 2n * (scaled % this.d) >= this.d ? q + 1n : q;
+		return new Fraction(this.n < 0n ? -rounded : rounded, scale);
+	}
+	/** The number of decimals when written out; Infinity when they never end (1/3). */
+	decimals() {
+		let d = this.d;
+		let twos = 0;
+		let fives = 0;
+		while (d % 2n === 0n) {
+			d /= 2n;
+			twos++;
+		}
+		while (d % 5n === 0n) {
+			d /= 5n;
+			fives++;
+		}
+		return d === 1n ? Math.max(twos, fives) : Infinity;
+	}
+	toNumber() {
+		return Number(this.n) / Number(this.d);
+	}
+	toString() {
+		return this.d === 1n ? String(this.n) : `${this.n}/${this.d}`;
+	}
+};
+// runtime/explainer/expression.ts
+/** A text in several languages, from a data file or a list: compared and sorted by its German text. */
+var Localized = class {
+	texts;
+	constructor(texts) {
+		this.texts = texts;
+	}
+	in(lang) {
+		return this.texts[lang] ?? this.texts["de"] ?? "";
+	}
+	toString() {
+		return this.in("de");
+	}
+};
+var ExpressionError = class extends Error {};
+/** The functions, with their number of arguments and which arguments are field names. */
+const FUNCTIONS = {
+	round: { arity: 2 },
+	decimals: { arity: 1 },
+	map: {
+		arity: 2,
+		field: 1
+	},
+	sortBy: {
+		arity: 2,
+		field: 1
+	},
+	reverse: { arity: 1 }
+};
+const KEYWORDS = /* @__PURE__ */ new Set([
+	"and",
+	"or",
+	"not",
+	"true",
+	"false"
+]);
+function tokens(source) {
+	const list = [];
+	const pattern = /\s*(?:(\d+(?:\.\d+)?)|"([^"]*)"|'([^']*)'|([A-Za-z_][A-Za-z0-9_]*)|(==|!=|<=|>=|[-+*/()<>[\],.]|=)|(\S))/y;
+	let match;
+	pattern.lastIndex = 0;
+	while (pattern.lastIndex < source.length && (match = pattern.exec(source)) !== null) {
+		const at = match.index + match[0].length - match[0].trimStart().length;
+		if (match[0].trim() === "") break;
+		if (match[1] !== void 0) list.push({
+			type: "number",
+			text: match[1],
+			at
+		});
+		else if (match[2] !== void 0 || match[3] !== void 0) list.push({
+			type: "string",
+			text: match[2] ?? match[3] ?? "",
+			at
+		});
+		else if (match[4] !== void 0) list.push({
+			type: "name",
+			text: match[4],
+			at
+		});
+		else if (match[5] !== void 0) {
+			if (match[5] === "=") throw new ExpressionError(`= at ${at + 1}: use == to compare`);
+			list.push({
+				type: "op",
+				text: match[5],
+				at
+			});
+		} else throw new ExpressionError(`unexpected ${match[6] ?? "character"} at ${at + 1}`);
+	}
+	list.push({
+		type: "end",
+		text: "the end",
+		at: source.length
+	});
+	return list;
+}
+/** Parses `source` into an expression; throws an ExpressionError that says where it does not parse. */
+function parse(source) {
+	const list = tokens(source);
+	let position = 0;
+	const peek = () => list[position] ?? {
+		type: "end",
+		text: "the end",
+		at: source.length
+	};
+	const next = () => {
+		const token = peek();
+		position++;
+		return token;
+	};
+	const isOp = (text) => peek().type === "op" && peek().text === text;
+	const isWord = (text) => peek().type === "name" && peek().text === text;
+	const expect = (text) => {
+		const token = next();
+		if (token.text !== text) throw new ExpressionError(`expected ${text} at ${token.at + 1}, found ${token.text}`);
+	};
+	const or = () => {
+		let left = and();
+		while (isWord("or")) {
+			next();
+			left = {
+				kind: "binary",
+				op: "or",
+				left,
+				right: and()
+			};
+		}
+		return left;
+	};
+	const and = () => {
+		let left = not();
+		while (isWord("and")) {
+			next();
+			left = {
+				kind: "binary",
+				op: "and",
+				left,
+				right: not()
+			};
+		}
+		return left;
+	};
+	const not = () => {
+		if (isWord("not")) {
+			next();
+			return {
+				kind: "unary",
+				op: "not",
+				arg: not()
+			};
+		}
+		return comparison();
+	};
+	const comparison = () => {
+		const left = sum();
+		const token = peek();
+		if (token.type === "op" && [
+			"==",
+			"!=",
+			"<",
+			"<=",
+			">",
+			">="
+		].includes(token.text)) {
+			next();
+			return {
+				kind: "binary",
+				op: token.text,
+				left,
+				right: sum()
+			};
+		}
+		return left;
+	};
+	const sum = () => {
+		let left = product();
+		while (isOp("+") || isOp("-")) left = {
+			kind: "binary",
+			op: next().text,
+			left,
+			right: product()
+		};
+		return left;
+	};
+	const product = () => {
+		let left = unary();
+		while (isOp("*") || isOp("/")) left = {
+			kind: "binary",
+			op: next().text,
+			left,
+			right: unary()
+		};
+		return left;
+	};
+	const unary = () => {
+		if (isOp("-")) {
+			next();
+			return {
+				kind: "unary",
+				op: "-",
+				arg: unary()
+			};
+		}
+		return postfix();
+	};
+	const postfix = () => {
+		let node = primary();
+		for (;;) if (isOp(".")) {
+			next();
+			const field = next();
+			if (field.type !== "name") throw new ExpressionError(`expected a field name at ${field.at + 1}`);
+			node = {
+				kind: "field",
+				of: node,
+				field: field.text
+			};
+		} else if (isOp("[")) {
+			next();
+			const index = or();
+			expect("]");
+			node = {
+				kind: "index",
+				of: node,
+				index
+			};
+		} else return node;
+	};
+	const primary = () => {
+		const token = next();
+		if (token.type === "number") return {
+			kind: "number",
+			value: Fraction.from(Number(token.text))
+		};
+		if (token.type === "string") return {
+			kind: "string",
+			value: token.text
+		};
+		if (token.type === "name") {
+			if (token.text === "true" || token.text === "false") return {
+				kind: "boolean",
+				value: token.text === "true"
+			};
+			if (KEYWORDS.has(token.text)) throw new ExpressionError(`unexpected ${token.text} at ${token.at + 1}`);
+			if (!isOp("(")) return {
+				kind: "name",
+				name: token.text
+			};
+			const fn = FUNCTIONS[token.text];
+			if (fn === void 0 || !Object.hasOwn(FUNCTIONS, token.text)) throw new ExpressionError(`${token.text} is not a function of the expression language; use one of ${Object.keys(FUNCTIONS).join(", ")}`);
+			next();
+			const args = [];
+			if (!isOp(")")) {
+				args.push(or());
+				while (isOp(",")) {
+					next();
+					args.push(or());
+				}
+			}
+			expect(")");
+			if (args.length !== fn.arity) throw new ExpressionError(`${token.text} takes ${fn.arity} argument${fn.arity === 1 ? "" : "s"}`);
+			if (fn.field !== void 0 && args[fn.field]?.kind !== "name") throw new ExpressionError(`the argument ${fn.field + 1} of ${token.text} is a field name, e.g. year`);
+			return {
+				kind: "call",
+				fn: token.text,
+				args
+			};
+		}
+		if (token.type === "op" && token.text === "(") {
+			const inner = or();
+			expect(")");
+			return inner;
+		}
+		if (token.type === "op" && token.text === "[") {
+			const items = [];
+			if (!isOp("]")) {
+				items.push(or());
+				while (isOp(",")) {
+					next();
+					items.push(or());
+				}
+			}
+			expect("]");
+			return {
+				kind: "list",
+				items
+			};
+		}
+		throw new ExpressionError(`unexpected ${token.text} at ${token.at + 1}`);
+	};
+	const tree = or();
+	const rest = peek();
+	if (rest.type !== "end") throw new ExpressionError(`unexpected ${rest.text} at ${rest.at + 1}`);
+	return tree;
+}
+/** The variables an expression uses: its names, not its functions or the field names they take. */
+function variables(node, into = /* @__PURE__ */ new Set()) {
+	switch (node.kind) {
+		case "name":
+			into.add(node.name);
+			break;
+		case "list":
+			for (const item of node.items) variables(item, into);
+			break;
+		case "field":
+			variables(node.of, into);
+			break;
+		case "index":
+			variables(node.of, into);
+			variables(node.index, into);
+			break;
+		case "call":
+			node.args.forEach((arg, index) => {
+				if (FUNCTIONS[node.fn]?.field !== index) variables(arg, into);
+			});
+			break;
+		case "unary":
+			variables(node.arg, into);
+			break;
+		case "binary":
+			variables(node.left, into);
+			variables(node.right, into);
+	}
+	return into;
+}
+const isList = (value) => Array.isArray(value);
+const isRecord = (value) => typeof value === "object" && !Array.isArray(value) && !(value instanceof Fraction) && !(value instanceof Localized);
+/** Whether two values are the same: numbers by value, texts by their German text, lists and records item by item. */
+function same(a, b) {
+	if (a instanceof Fraction || b instanceof Fraction) return a instanceof Fraction && b instanceof Fraction && a.equals(b);
+	if (isList(a) || isList(b)) return isList(a) && isList(b) && a.length === b.length && a.every((item, index) => same(item, b[index]));
+	if (typeof a === "boolean" || typeof b === "boolean") return a === b;
+	if (isRecord(a) || isRecord(b)) {
+		if (!isRecord(a) || !isRecord(b)) return false;
+		const keys = Object.keys(a);
+		return keys.length === Object.keys(b).length && keys.every((key) => key in b && same(a[key], b[key]));
+	}
+	return String(a) === String(b);
+}
+/** The order of two values: numbers by value, texts by their German text. */
+function order(a, b, what) {
+	if (a instanceof Fraction && b instanceof Fraction) return a.compare(b);
+	const text = (value) => typeof value === "string" || value instanceof Localized ? String(value) : void 0;
+	const left = text(a);
+	const right = text(b);
+	if (left === void 0 || right === void 0) throw new ExpressionError(`${what} compares numbers or texts`);
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+const describe = (value) => value instanceof Fraction ? "a number" : typeof value === "string" || value instanceof Localized ? "a text" : typeof value === "boolean" ? "true or false" : isList(value) ? "a list" : "a record";
+function asNumber(value, what) {
+	if (!(value instanceof Fraction)) throw new ExpressionError(`${what} needs numbers, not ${describe(value)}`);
+	return value;
+}
+function asList(value, what) {
+	if (!isList(value)) throw new ExpressionError(`${what} needs a list, not ${describe(value)}`);
+	return value;
+}
+function asBoolean(value, what) {
+	if (typeof value !== "boolean") throw new ExpressionError(`${what} needs true or false, not ${describe(value)}`);
+	return value;
+}
+function fieldOf(value, field) {
+	if (!isRecord(value)) throw new ExpressionError(`.${field} needs a record, not ${describe(value)}`);
+	if (!Object.hasOwn(value, field)) throw new ExpressionError(`the record has no field ${field}; it has ${Object.keys(value).join(", ")}`);
+	return value[field];
+}
+function integer(value, what) {
+	if (!value.isInteger()) throw new ExpressionError(`${what} needs a whole number`);
+	return Number(value.n);
+}
+function call(fn, args, env) {
+	const value = (index) => evaluate(args[index], env);
+	const field = () => args[1].name;
+	switch (fn) {
+		case "round": return asNumber(value(0), "round").round(integer(asNumber(value(1), "round"), "round"));
+		case "decimals": {
+			const places = asNumber(value(0), "decimals").decimals();
+			return Fraction.of(places === Infinity ? 1e6 : places);
+		}
+		case "map": return asList(value(0), "map").map((item) => fieldOf(item, field()));
+		case "sortBy": {
+			const name = field();
+			return [...asList(value(0), "sortBy")].sort((a, b) => order(fieldOf(a, name), fieldOf(b, name), "sortBy"));
+		}
+		case "reverse": return [...asList(value(0), "reverse")].reverse();
+		default: throw new ExpressionError(`${fn} is not a function of the expression language`);
+	}
+}
+/** The value of an expression with the variables of `env`; throws an ExpressionError when it has none. */
+function evaluate(node, env) {
+	switch (node.kind) {
+		case "number":
+		case "string":
+		case "boolean": return node.value;
+		case "name":
+			if (!Object.hasOwn(env, node.name)) throw new ExpressionError(`${node.name} is not declared`);
+			return env[node.name];
+		case "list": return node.items.map((item) => evaluate(item, env));
+		case "field": return fieldOf(evaluate(node.of, env), node.field);
+		case "index": {
+			const list = asList(evaluate(node.of, env), "[…]");
+			const index = integer(asNumber(evaluate(node.index, env), "[…]"), "[…]");
+			if (index < 0 || index >= list.length) throw new ExpressionError(`the list has no element ${index}; it has ${list.length}, from 0`);
+			return list[index];
+		}
+		case "call": return call(node.fn, node.args, env);
+		case "unary": {
+			const arg = evaluate(node.arg, env);
+			return node.op === "-" ? asNumber(arg, "-").neg() : !asBoolean(arg, "not");
+		}
+		case "binary": {
+			if (node.op === "and") return asBoolean(evaluate(node.left, env), "and") && asBoolean(evaluate(node.right, env), "and");
+			if (node.op === "or") return asBoolean(evaluate(node.left, env), "or") || asBoolean(evaluate(node.right, env), "or");
+			const left = evaluate(node.left, env);
+			const right = evaluate(node.right, env);
+			switch (node.op) {
+				case "+": return asNumber(left, "+").add(asNumber(right, "+"));
+				case "-": return asNumber(left, "-").sub(asNumber(right, "-"));
+				case "*": return asNumber(left, "*").mul(asNumber(right, "*"));
+				case "/": {
+					const divisor = asNumber(right, "/");
+					if (divisor.n === 0n) throw new ExpressionError("division by zero");
+					return asNumber(left, "/").div(divisor);
+				}
+				case "==": return same(left, right);
+				case "!=": return !same(left, right);
+				default: {
+					const sign = order(left, right, node.op);
+					return node.op === "<" ? sign < 0 : node.op === "<=" ? sign <= 0 : node.op === ">" ? sign > 0 : sign >= 0;
+				}
+			}
+		}
+	}
+}
+// runtime/explainer/generated/comparator.ts
+/** What the comparator of an exercise is. */
+function kindOf(compare) {
+	if (compare === "number") return {
+		kind: "number",
+		decimals: 2,
+		tolerance: Fraction.of(0),
+		money: false
+	};
+	if (compare === "order") return { kind: "order" };
+	if (compare === "pairs") return { kind: "pairs" };
+	if ("number" in compare) {
+		const { format = "decimal", decimals, tolerance = 0, unit } = compare.number;
+		const places = decimals ?? (format === "integer" ? 0 : 2);
+		const shown = unit ?? (format === "money" ? "€" : format === "percent" ? "%" : void 0);
+		return {
+			kind: "number",
+			decimals: places,
+			tolerance: Fraction.from(tolerance),
+			money: format === "money",
+			...shown === void 0 ? {} : { unit: shown }
+		};
+	}
+	if ("choice" in compare) return {
+		kind: "choice",
+		options: compare.choice
+	};
+	return {
+		kind: "pairs",
+		left: compare.pairs.left,
+		right: compare.pairs.right
+	};
+}
+// runtime/explainer/generated/texts.ts
+const PATH = String.raw`[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*`;
+/** A placeholder: two braces around a name or a name's field, nothing else inside. */
+const PLACEHOLDER = new RegExp(String.raw`\{\{(${PATH})\}\}`, "g");
+/** What looks meant as a placeholder but is not one: one brace in prose, or spaces inside two braces. */
+const ONE_BRACE = new RegExp(String.raw`(?<!\{)\{(${PATH})\}(?!\})`, "g");
+/** Anything between two braces, as written: a placeholder, or what only looks like one ({{opts[0].x}}, {{}}, {{1x}}). */
+const BRACED = /\{\{([^{}]*)\}\}/g;
+const PATH_ONLY = new RegExp(String.raw`^${PATH}$`);
+const SPACED = new RegExp(String.raw`\{\{\s*(${PATH})\s*\}\}`, "g");
+/** A formula ($…$) or a run of prose, in a template. */
+const SEGMENT = /\$((?:\\.|[^\\$\n])+?)\$|([^$]+)/g;
+const formats = /* @__PURE__ */ new Map();
+/** A number as the page shows it: up to six decimals, no grouping (a learner would type 1500, not 1.500). */
+function formatNumber(value, lang, decimals) {
+	const key = `${lang}:${decimals ?? ""}`;
+	let format = formats.get(key);
+	if (format === void 0) {
+		format = new Intl.NumberFormat(localeOf(lang), {
+			maximumFractionDigits: decimals ?? 6,
+			...decimals === void 0 ? {} : { minimumFractionDigits: decimals },
+			useGrouping: false
+		});
+		formats.set(key, format);
+	}
+	return format.format(value.toNumber());
+}
+/** A value as the learner reads it, in `lang`. */
+function label(value, lang) {
+	if (value instanceof Fraction) return formatNumber(value, lang);
+	if (value instanceof Localized) return value.in(lang);
+	if (typeof value === "string") return value;
+	if (typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return value.map((item) => label(item, lang)).join(", ");
+	throw new ExpressionError("a record cannot be shown; name one of its fields, e.g. {{e.name}}");
+}
+/** The answer as the learner reads it: a sum of money with two decimals when it has any. */
+function answerLabel(spec, task, lang) {
+	const kind = kindOf(spec.answer.compare);
+	if (kind.kind === "number" && task.answer instanceof Fraction) return formatNumber(task.answer, lang, kind.money && !task.answer.isInteger() ? 2 : void 0);
+	return label(task.answer, lang);
+}
+/** A template's placeholders as tokens: {{G}} becomes ⟦G⟧, inside a formula ($…$) {\text{⟦G⟧}}. */
+function tokenize(text) {
+	return text.replace(SEGMENT, (whole, math, prose) => math !== void 0 ? `$${math.replace(PLACEHOLDER, (_placeholder, path) => `{\\text{⟦${path}⟧}}`)}$` : (prose ?? whole).replace(PLACEHOLDER, (_placeholder, path) => `⟦${path}⟧`));
+}
+/** The placeholders of a template, by their path (G, e.name, answer). */
+function placeholdersIn(text) {
+	return [...text.matchAll(PLACEHOLDER)].map((match) => match[1] ?? "");
+}
+/**
+* The problems of the placeholders of one template: unknown roots, one brace in prose, spaces inside, and double
+* braces around anything but a name or a name's field (an index, a number, nothing). A literal {{ in a formula is
+* written { { }.
+*/
+function placeholderProblems(text, known) {
+	const problems = [];
+	const list = [...known].map((name) => `{{${name}}}`).join(", ");
+	for (const path of placeholdersIn(text)) {
+		const root = path.split(".")[0] ?? "";
+		if (!known.has(root)) problems.push(`{{${path}}} is an unknown placeholder: ${root} is not declared in given; declare it, or use one of ${list}`);
+	}
+	for (const match of text.matchAll(SPACED)) if (match[0] !== `{{${match[1]}}}`) problems.push(`${match[0]} has spaces inside; a placeholder is written {{${match[1]}}}, without spaces`);
+	for (const match of text.matchAll(BRACED)) {
+		const inner = match[1] ?? "";
+		if (PATH_ONLY.test(inner) || PATH_ONLY.test(inner.trim())) continue;
+		problems.push(`${match[0]} is no placeholder: a placeholder is a name or a name's field ({{e.brauch}}); to show one record, pick it on its own (given: { e: { pick: 1, from: { data: feste } } }) and write {{e.brauch}}; a literal {{ in a formula is written { {`);
+	}
+	for (const match of text.matchAll(SEGMENT)) {
+		if (match[2] === void 0) continue;
+		for (const one of match[2].matchAll(ONE_BRACE)) {
+			const root = (one[1] ?? "").split(".")[0] ?? "";
+			if (known.has(root)) problems.push(`{${one[1]}} has one pair of braces; a placeholder is written with two: {{${one[1]}}}`);
+		}
+	}
+	return problems;
+}
+/** The templates of an exercise as written: the task, the steps, the hint and the messages. */
+function writtenTemplates(spec) {
+	const written = [];
+	const add = (path, text) => {
+		if (text === void 0) return;
+		if (typeof text === "string") written.push({
+			path,
+			text
+		});
+		else for (const [lang, each] of Object.entries(text)) written.push({
+			path: [...path, lang],
+			lang,
+			text: each
+		});
+	};
+	add(["task", "text"], spec.task.text);
+	(spec.steps ?? []).forEach((step, index) => add(["steps", index], step));
+	add(["hint"], spec.hint);
+	(spec.mistakes ?? []).forEach((mistake, index) => add([
+		"mistakes",
+		index,
+		"message"
+	], mistake.message));
+	return written;
+}
+/** The problems of the placeholders of an exercise's templates, each at its path. */
+function templateProblems(spec) {
+	const declared = [...Object.keys(spec.given), "answer"];
+	return writtenTemplates(spec).flatMap(({ path, lang, text }) => {
+		return placeholderProblems(text, new Set(declared)).map((message) => ({
+			path,
+			...lang === void 0 ? {} : { lang },
+			message
+		}));
+	});
+}
+/**
+* The variables of `given` that the exercise never uses: in no placeholder of its templates, and in none of the
+* expressions of the answer (with the options of a choice) and the mistakes. `where` does not
+* count: a value drawn only to be filtered is never seen.
+*/
+function unusedVariables(spec) {
+	const used = /* @__PURE__ */ new Set();
+	for (const { text } of writtenTemplates(spec)) for (const path of placeholdersIn(text)) used.add(path.split(".")[0] ?? "");
+	const expressions = [spec.answer.value, ...(spec.mistakes ?? []).map((mistake) => mistake.value)];
+	const compare = spec.answer.compare;
+	if (typeof compare === "object") {
+		const options = compare["choice"];
+		if (typeof options === "string") expressions.push(options);
+	}
+	for (const source of expressions) try {
+		variables(parse(source), used);
+	} catch {}
+	return Object.keys(spec.given).filter((name) => !used.has(name));
+}
+/** The value of a placeholder's path in a task, or undefined when it has none. */
+function placeholderValue(spec, task, path, lang) {
+	if (path === "answer") return {
+		text: answerLabel(spec, task, lang),
+		...task.answer instanceof Fraction ? { number: task.answer } : {}
+	};
+	try {
+		const value = evaluate(parse(path), task.values);
+		return {
+			text: label(value, lang),
+			...value instanceof Fraction ? { number: value } : {}
+		};
+	} catch {
+		return;
+	}
+}
+/** A template with the values of a task: HTML (escaped, numbers in formulas as <mn>) or plain text. */
+function fill(template, spec, task, lang, mode = "html") {
+	return (mode === "html" ? template.replace(/<mtext>⟦([^⟧]+)⟧<\/mtext>/g, (_whole, path) => {
+		const value = placeholderValue(spec, task, path, lang);
+		if (value === void 0) return `<mtext>{{${escape(path)}}}</mtext>`;
+		if (value.number === void 0) return `<mtext>${escape(value.text)}</mtext>`;
+		const negative = value.number.compare(Fraction.of(0)) < 0;
+		const digits = escape(negative ? value.text.replace(/^[-−]/, "") : value.text);
+		return negative ? `<mo>−</mo><mn>${digits}</mn>` : `<mn>${digits}</mn>`;
+	}) : template).replace(/⟦([^⟧]+)⟧/g, (_whole, path) => {
+		const value = placeholderValue(spec, task, path, lang);
+		if (value === void 0) return `{{${path}}}`;
+		return mode === "html" ? escape(value.text) : value.text;
+	});
+}
+const templatesIn = (templates, lang) => templates[lang] ?? templates["de"] ?? {
+	task: "",
+	steps: [],
+	messages: []
+};
+/** The task's text as HTML, in `lang`. */
+function taskText(spec, task, lang, templates) {
+	return fill(templatesIn(templates, lang).task, spec, task, lang);
+}
+/** The steps of the solution as HTML, in `lang`. */
+function stepsOf(spec, task, lang, templates) {
+	return templatesIn(templates, lang).steps.map((step) => fill(step, spec, task, lang));
+}
+/** The hint as HTML, in `lang`, if the exercise has one. */
+function hintOf(spec, task, lang, templates) {
+	const hint = templatesIn(templates, lang).hint;
+	return hint === void 0 ? void 0 : fill(hint, spec, task, lang);
+}
+/** The text of HTML, as a learner reads it: tags left out, entities resolved, white space folded. */
+function plainText(html) {
+	return html.replace(/<[^>]*>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;/g, "'").replace(/&amp;/g, "&").replace(/\s+/g, " ").trim();
+}
+// runtime/explainer/generated/question.ts
+const listOf = (value, what) => {
+	if (!Array.isArray(value)) throw new ExpressionError(`the answer of ${what} is a list`);
+	return value;
+};
+/** The task as the question of the comparator's kind, in `lang`. */
+function questionFor(spec, task, lang, templates) {
+	const kind = kindOf(spec.answer.compare);
+	const base = {
+		id: `${spec.id}-${task.seed}`,
+		text: plainText(taskText(spec, task, lang, templates)),
+		explanation: "",
+		links: []
+	};
+	switch (kind.kind) {
+		case "number":
+			if (!(task.answer instanceof Fraction)) throw new ExpressionError("the answer of number is a number");
+			return {
+				...base,
+				type: "number",
+				answer: task.answer.toNumber(),
+				tolerance: kind.tolerance.toNumber(),
+				...kind.unit === void 0 ? {} : { unit: inLanguage(kind.unit, lang) }
+			};
+		case "choice": return {
+			...base,
+			type: "single-choice",
+			options: (task.options ?? []).map((option) => ({
+				text: label(option, lang),
+				correct: same(task.answer, option),
+				info: ""
+			}))
+		};
+		case "order": return {
+			...base,
+			type: "ordering",
+			items: listOf(task.answer, "order").map((item) => label(item, lang))
+		};
+		case "pairs": return {
+			...base,
+			type: "matching",
+			pairs: pairValues(spec, task.answer).map(([left, right]) => ({
+				left: label(left, lang),
+				right: label(right, lang)
+			}))
+		};
+	}
+}
+/** The pairs of a pairs answer, as values: [left, right]. */
+function pairValues(spec, value) {
+	const kind = kindOf(spec.answer.compare);
+	return listOf(value, "pairs").map((item) => {
+		if (kind.kind === "pairs" && kind.left !== void 0 && kind.right !== void 0) {
+			const fields = item;
+			return [fields[kind.left] ?? "", fields[kind.right] ?? ""];
+		}
+		if (!Array.isArray(item) || item.length !== 2) throw new ExpressionError("each pair is a list of two: [left, right]");
+		return [item[0], item[1]];
+	});
+}
+/** The learner's answer that gives `value` (e.g. a mistake) through the controls of the task's question. */
+function answerGiving(spec, task, value) {
+	const kind = kindOf(spec.answer.compare);
+	const index = (list, item) => list.findIndex((other) => same(other, item));
+	switch (kind.kind) {
+		case "number": {
+			if (!(value instanceof Fraction)) throw new ExpressionError("a mistake of number is a number");
+			const places = Math.min(value.decimals(), Math.max(kind.decimals, 2));
+			return formatNumber(value.round(places), "de");
+		}
+		case "choice": {
+			const at = index(task.options ?? [], value);
+			if (at < 0) throw new ExpressionError(`${label(value, "de")} is not one of the choices`);
+			return at;
+		}
+		case "order": {
+			const order = listOf(value, "order");
+			return listOf(task.answer, "order").map((item) => index(order, item));
+		}
+		case "pairs": {
+			const right = pairValues(spec, task.answer);
+			const given = pairValues(spec, value);
+			return right.map(([left]) => {
+				const chosen = given.find(([other]) => same(other, left))?.[1];
+				return chosen === void 0 ? -1 : right.findIndex(([, other]) => same(other, chosen));
+			});
+		}
+	}
+}
+/**
+* The learner's answer that gives `value`, an example, through the controls of the task's question: as answerGiving,
+* but a number as it is, with up to six decimals, so an example just outside the tolerance stays outside.
+*/
+function exampleGiving(spec, task, value) {
+	if (kindOf(spec.answer.compare).kind !== "number") return answerGiving(spec, task, value);
+	if (!(value instanceof Fraction)) throw new ExpressionError("an example of number is a number");
+	return formatNumber(value, "de");
+}
+/** The learner's answer that gives the mistake `index` of a task, through the controls of its question. */
+function answerFor(spec, task, _question, index) {
+	return answerGiving(spec, task, task.mistakes[index]);
+}
+/** Whether two answers to `question` are the same, a number within `slack`. */
+function sameAnswer(question, a, b, slack) {
+	if (question.type === "number") {
+		const left = typeof a === "string" ? parseNumber(a, question.unit) : void 0;
+		const right = typeof b === "string" ? parseNumber(b, question.unit) : void 0;
+		return left !== void 0 && right !== void 0 && Math.abs(left - right) <= slack + 1e-9;
+	}
+	if (Array.isArray(a) && Array.isArray(b)) return a.join() === b.join();
+	return a === b;
+}
+/** The index of the first typical mistake the learner's wrong answer makes; undefined when it makes none. */
+function mistakeOf(spec, task, question, answer) {
+	if (isCorrect(question, answer)) return void 0;
+	const kind = kindOf(spec.answer.compare);
+	const slack = kind.kind === "number" ? Math.max(kind.tolerance.toNumber(), .5 * 10 ** -Math.max(kind.decimals, 2)) : 0;
+	for (const [index] of task.mistakes.entries()) try {
+		if (sameAnswer(question, answer, answerFor(spec, task, question, index), slack)) return index;
+	} catch {}
+}
+/** The message of the first mistake the learner's wrong answer makes, in `lang`; undefined when it makes none. */
+function diagnose(spec, task, question, answer, lang, templates) {
+	const index = mistakeOf(spec, task, question, answer);
+	if (index === void 0) return void 0;
+	return fill(templatesIn(templates, lang).messages[index] ?? "", spec, task, lang, "text");
+}
+/** What a learner sees of a task: its text and its question's options, items or pairs; "Neue Aufgabe" changes it. */
+function taskKey(spec, task, lang, templates) {
+	const { id: _id, ...question } = questionFor(spec, task, lang, templates);
+	return JSON.stringify(question);
+}
+const literal$1 = (value) => typeof value === "number" ? Fraction.from(value) : typeof value === "string" ? value : new Localized(value);
+/** A value of a data record: a map of strings is a text by language, any other map a record. */
+function dataValue(value) {
+	if (typeof value === "number") return Fraction.from(value);
+	if (typeof value === "boolean" || typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map(dataValue);
+	return Object.entries(value).every(([, field]) => typeof field === "string") ? new Localized(value) : record(value);
+}
+function record(source) {
+	return Object.fromEntries(Object.entries(source).map(([key, value]) => [key, dataValue(value)]));
+}
+function items(source, data) {
+	if (Array.isArray(source)) return source.map(literal$1);
+	const name = source.data;
+	const records = data[name];
+	if (records === void 0) throw new ExpressionError(`src/data/${name}.yaml does not exist`);
+	return records.map(record);
+}
+/** The value of one arbitrary, drawn with `next`. */
+function draw(arbitrary, next, data) {
+	const range = arbitrary.int ?? arbitrary.decimal;
+	if (range !== void 0) {
+		const [min, max] = range;
+		const step = Fraction.from(arbitrary.step ?? 1);
+		const low = Fraction.from(min);
+		const count = Math.floor(Fraction.from(max).sub(low).div(step).toNumber() + 1e-9) + 1;
+		return low.add(step.mul(Fraction.of(Math.floor(next() * count))));
+	}
+	if (arbitrary.oneOf !== void 0) {
+		const list = arbitrary.oneOf;
+		return literal$1(list[Math.floor(next() * list.length)]);
+	}
+	const list = items(arbitrary.from ?? [], data);
+	const count = arbitrary.pick ?? 1;
+	const picked = [];
+	if (arbitrary.distinct === true) {
+		const order = shuffled(list.length, Math.floor(next() * 2 ** 31));
+		for (const index of order.slice(0, count)) picked.push(list[index]);
+	} else for (let i = 0; i < count; i++) picked.push(list[Math.floor(next() * list.length)]);
+	return count === 1 && arbitrary.pick === 1 ? picked[0] : picked;
+}
+const compiledCache = /* @__PURE__ */ new WeakMap();
+function compiled(spec) {
+	let found = compiledCache.get(spec);
+	if (found === void 0) {
+		const kind = kindOf(spec.answer.compare);
+		found = {
+			where: (spec.where ?? []).map((source) => parse(source)),
+			answer: parse(spec.answer.value),
+			mistakes: (spec.mistakes ?? []).map((mistake) => parse(mistake.value)),
+			...kind.kind === "choice" && typeof kind.options === "string" ? { options: parse(kind.options) } : {}
+		};
+		compiledCache.set(spec, found);
+	}
+	return found;
+}
+/** The values of `given` for a seed and an attempt. */
+function values(spec, seed, attempt, data) {
+	const next = random(hash(`${spec.id}#${seed}#${attempt}`));
+	const drawn = {};
+	for (const [name, arbitrary] of Object.entries(spec.given)) drawn[name] = draw(arbitrary, next, data);
+	return drawn;
+}
+/** Whether every precondition holds for these values. */
+function holds(spec, env) {
+	return compiled(spec).where.every((condition, index) => {
+		const value = evaluate(condition, env);
+		if (typeof value !== "boolean") throw new ExpressionError(`where[${index}] needs true or false, not a value`);
+		return value;
+	});
+}
+/** Thrown when no draw of a seed passes `where`. */
+var StarvedError = class extends ExpressionError {};
+/** The task of `seed`: the first draw whose values pass `where`, with the answer, the mistakes and the options. */
+function generate(spec, seed, data) {
+	const code = compiled(spec);
+	for (let attempt = 0; attempt < 100; attempt++) {
+		const env = values(spec, seed, attempt, data);
+		if (!holds(spec, env)) continue;
+		const task = {
+			seed,
+			values: env,
+			answer: evaluate(code.answer, env),
+			mistakes: code.mistakes.map((mistake) => evaluate(mistake, env))
+		};
+		const kind = kindOf(spec.answer.compare);
+		if (kind.kind === "choice") {
+			const options = code.options === void 0 ? kind.options.map(literal$1) : evaluate(code.options, env);
+			if (!Array.isArray(options)) throw new ExpressionError(`the options of choice are not a list`);
+			task.options = [...options];
+		}
+		return task;
+	}
+	throw new StarvedError(`where holds in none of 100 draws for seed ${seed}`);
+}
+// runtime/explainer/messages.ts
+const MESSAGES = {
+	de: {
+		language: "Deutsch",
+		languages: "Sprache",
+		start: "Start",
+		breadcrumbs: "Du bist hier",
+		contents: "Inhalt",
+		onThisPage: "Auf dieser Seite",
+		pages: "Seiten",
+		chapters: "Kapitel",
+		pager: "Weiterblättern",
+		previous: "Zurück: {title}",
+		next: "Weiter: {title}",
+		glossary: "Glossar",
+		glossaryIntro: "Die Begriffe dieser App, von A bis Z, jeder mit der Seite, die ihn erklärt.",
+		inGlossary: "im Glossar",
+		explainedOn: "Erklärt auf der Seite {page}",
+		sources: "Quellen",
+		sourcesIntro: "Die Fakten in dieser App stammen aus diesen Quellen:",
+		beforeChrist: "{year} v. Chr.",
+		code: "Code in {language}",
+		footer: "Eine Erklär-App auf lernapps.net",
+		imprint: "Impressum",
+		privacy: "Datenschutz",
+		workedTasks: "Drei Beispielaufgaben, jede mit ihrer Lösung:",
+		practice: "Übe selbst, mit immer neuen Aufgaben:",
+		newTask: "Neue Aufgabe",
+		hint: "Tipp",
+		textDescription: "Beschreibung als Text",
+		taskNumber: "Aufgabe Nr. {n}",
+		backToTutor: "Zurück zum Tutor",
+		backToTutorOpen: "Wechsel zurück zum Chat mit {name}.",
+		backToTutorCopied: "Wechsel zurück zu {name} und füg es dort ein. Diesen Tab kannst du offen lassen.",
+		backToTutorFailed: "Kopieren ging nicht. Kopier die markierten Zeilen, wechsel zurück zu {name} und füg sie dort ein.",
+		resultLabel: "Ergebniszeile für deinen Tutor",
+		resultLine: "{page}, {exercise}{number}: {status}.",
+		resultNumber: ", Nr. {n}",
+		resultRight: "richtig im {n}. Versuch",
+		resultSolution: "Lösung angesehen",
+		resultOpen: "noch nicht gelöst",
+		resultTry: "1 Versuch",
+		resultTries: "{n} Versuche",
+		resultInput: "Eingabe {input}",
+		resultSession: "Sitzung: {right} von {total} richtig.",
+		resultTutor: "Tutor-Seite:",
+		resultTrue: "stimmt",
+		resultFalse: "stimmt nicht",
+		stuckAsk: "Lade {url} und hilf mir bei Übung {exercise}{number}. Ich komme nicht weiter.",
+		stuckTask: "Übung {exercise}{number}:",
+		stuckInput: "Ich habe {input} eingegeben ({tries}).",
+		stuckTries: "Bisher {tries}.",
+		stuckRight: "Ich habe sie im {n}. Versuch richtig gelöst.",
+		stuckMessage: "Die App sagt: „{message}“",
+		stuckHint: "Ich habe den Tipp geöffnet.",
+		stuckSolution: "Ich habe mir die Lösung angesehen.",
+		stuckPrivacy: "„Warum?“ gibt {name} mit deinem Klick die Aufgabe, deine Eingabe und die Meldung der App.",
+		stuckPrivacyCopy: "Dein Klick kopiert die Aufgabe, deine Eingabe und die Meldung der App für den Chat mit deinem Tutor; die App schickt nichts weg.",
+		stuckCopied: "Wechsel zurück zu {name} und füg die Zeilen dort ein.",
+		stuckFailed: "Kopieren ging nicht. Kopier die markierten Zeilen, wechsel zurück zu {name} und füg sie dort ein.",
+		stuckLabel: "Zeilen für deinen Tutor",
+		tutorTitle: "Mit einem KI-Tutor lernen",
+		tutorAbout: "Ein KI-Tutor ist ein KI-Assistent deiner Wahl, der dich beim Lernen mit dieser App begleitet. Er erklärt dir den Stoff mit den Beispielen der Seiten, gibt dir Aufgaben aus der App und hilft dir, wenn du nicht weiterkommst. Gelöst wird in der App: Sie prüft deine Antworten.",
+		tutorAboutStart: "Wähl hier deinen Assistenten. Dann steht er auf jeder Seite unter dem Titel bereit, und jede Übung hat den Knopf „Hilfe“. Du kannst ihn auch auf einer Seite unter dem Titel einschalten.",
+		tutorAboutPrivacy: "Deine Wahl bleibt auf diesem Gerät; erst dein Klick öffnet den Assistenten. Frag deine Eltern oder Lehrkraft, ob du ihn nutzen darfst.",
+		tutorAccount: "Du nutzt dein eigenes Konto beim Anbieter. Der Assistent ist kein Angebot von lernapps.net: lernapps liefert nur Inhalte und Übungen.",
+		tutorScope: "Die Wahl gilt für alle Seiten, nur auf diesem Gerät.",
+		tutorChoose: "Dein KI-Assistent",
+		tutorNone: "Keiner",
+		needsTitle: "Was dir beim Lernen hilft",
+		needsOpen: "Einstellungen",
+		needsDone: "Fertig",
+		needsAbout: "Hier kannst du deinem Tutor sagen, wie er mit dir sprechen soll. Kreuz an, was dir hilft; du kannst mehreres wählen.",
+		needKurzeSchritte: "Kurze Schritte",
+		needKurzeSchritteAbout: "Der Tutor erklärt in kleinen Schritten, immer nur eine Sache auf einmal. Du weißt immer, wie weit es noch ist.",
+		needWenigLesen: "Wenig lesen",
+		needWenigLesenAbout: "Der Tutor schreibt sehr kurz und einfach und erklärt jedes Fachwort. Tipp: Lass dir seine Antworten vorlesen und sprich deine Antwort ein.",
+		needMehrTiefe: "Mehr Tiefe",
+		needMehrTiefeAbout: "Der Tutor überspringt, was du schon kannst, und stellt dir knifflige Warum- und Was-wäre-wenn-Fragen.",
+		needAndereMuttersprache: "Andere Muttersprache",
+		needAndereMutterspracheAbout: "Der Tutor erklärt auf Deutsch in einfachen Sätzen und übersetzt neue Fachwörter in deine Sprache. Du darfst auch in deiner Sprache schreiben.",
+		needKlarUndWoertlich: "Klar und wörtlich",
+		needKlarUndWoertlichAbout: "Der Tutor schreibt genau das, was er meint: ohne Witze, versteckte Bedeutungen oder Redewendungen. Er sagt dir immer, wo ihr gerade seid.",
+		needRechnenAnschaulich: "Rechnen anschaulich",
+		needRechnenAnschaulichAbout: "Der Tutor zeigt dir, wie viel eine Zahl ist, und erklärt in kleinen Schritten. Du rechnest selbst und hast so viel Zeit, wie du brauchst.",
+		needsLanguage: "Deine Muttersprache",
+		needsLanguageNone: "Bitte wählen",
+		needsScopeTitle: "Das gilt",
+		needsScopeAll: "für alle Erklär-Apps auf lernapps.net",
+		needsScopeApp: "nur für diese App",
+		needsPrivacy: "Deine Wahl bleibt auf diesem Gerät. Der Tutor bekommt nur die Namen der Einstellungen, die du ankreuzt, und erst, wenn du ihn öffnest.",
+		tutorOther: "Ein anderer: Text kopieren",
+		tutorOn: "Einschalten",
+		tutorSomeone: "deinen KI-Tutor",
+		help: "Hilfe",
+		helpWhy: "Warum?",
+		helpBack: "Zurück",
+		helpLabel: "{name} um Hilfe bitten",
+		helpWhyLabel: "{name} fragen, warum",
+		helpBackLabel: "Zurück zu {name}",
+		tutorCopy: "Text kopieren",
+		tutorOpenWith: "Mit {name} öffnen",
+		tutorGo: "Mit {name} lernen",
+		tutorWay: "Assistent",
+		tutorPageIntro: "Ein KI-Tutor erklärt dir diese Seite und hilft dir bei den Übungen. Wähl deinen Assistenten:",
+		tutorPageLink: "Ansehen, was dein Tutor zu dieser Seite bekommt",
+		tutorPasteHint: "{name} lädt keine Webseiten, wenn der Link aus einem Knopf kommt. Darum kopieren wir den Satz mit dem Link für dich. Ein Klick auf „Mit {name} lernen“ öffnet {name} mit einer kurzen Nachricht. Füg danach den kopierten Satz ein (Strg+V, am Mac ⌘+V) und schick ihn ab.",
+		tutorDone: "✓ Kopiert – jetzt in {name} einfügen",
+		tutorCopied: "Der Prompt ist kopiert. Füg ihn in den Chat deines KI-Assistenten ein.",
+		tutorCopyFailed: "Kopieren ging nicht. Versuch es noch einmal.",
+		exerciseLabel: "Übung",
+		videoChannel: "{channel} · YouTube",
+		videoNote: "Beim Abspielen gehen Daten an YouTube/Google, darunter deine IP-Adresse.",
+		videoPlay: "Video abspielen",
+		videoAlways: "Videos immer direkt laden",
+		assessmentTitle: "Selbsteinschätzung",
+		assessmentOfferTitle: "Was kannst du schon?",
+		assessmentOfferApp: "Freiwillig: Bevor du anfängst, kannst du {count} Aufgaben aus dieser App lösen. Am Ende siehst du für jede Seite, ob du sie dir genauer ansehen solltest.",
+		assessmentOfferChapter: "Freiwillig: Bevor du anfängst, kannst du {count} Aufgaben aus diesem Kapitel lösen. Am Ende siehst du für jede Seite, ob du sie dir genauer ansehen solltest.",
+		assessmentOfferStart: "Selbsteinschätzung starten",
+		assessmentOfferLast: "Dein letztes Ergebnis ansehen",
+		assessmentIntro: "Mit dieser Selbsteinschätzung bekommst du mit {count} Aufgaben einen Überblick, was du schon kannst.",
+		assessmentAllAsked: "Sie fragt jede Seite ab.",
+		assessmentLeftOut: "{n} Seiten fragt sie nicht ab. Es lohnt sich also, sie einmal anzuschauen:",
+		assessmentLeftOutOne: "Eine Seite fragt sie nicht ab. Es lohnt sich also, sie einmal anzuschauen:",
+		assessmentHow: "Die App sagt dir nicht bei jeder Aufgabe, ob sie stimmt. Erst am Ende siehst du für jede abgefragte Seite, ob du sie schon kannst. Was du leer lässt, zählt als nicht gekonnt.",
+		assessmentPrivacy: "Dein Ergebnis bleibt nur auf diesem Gerät. Ein neuer Start ersetzt es.",
+		assessmentBegin: "Los geht's",
+		assessmentStep: "Seite {n} von {count}",
+		assessmentTask: "Aufgabe {n}",
+		assessmentBack: "Zurück",
+		assessmentNext: "Weiter",
+		assessmentFinish: "Auswerten",
+		assessmentResultTitle: "Dein Ergebnis",
+		assessmentScore: "Du hast {right} von {total} Aufgaben richtig gelöst.",
+		assessmentScorePartly: "Du hast {right} von {total} Aufgaben richtig gelöst und {partly} teilweise.",
+		assessmentAdvice: "Fang mit den Seiten an, die du genau lesen solltest.",
+		assessmentAllKnown: "Die abgefragten Seiten kannst du wahrscheinlich schon. Üb trotzdem auf den Seiten, damit es sicher sitzt.",
+		assessmentKnown: "Kannst du wahrscheinlich schon",
+		assessmentPartly: "Schau sie dir noch einmal an",
+		assessmentRead: "Lies sie genau",
+		assessmentUnasked: "Nicht abgefragt",
+		assessmentPageScore: "{right} von {total} richtig",
+		assessmentPageScorePartly: "{right} von {total} richtig, {partly} teilweise",
+		assessmentRestart: "Neu starten",
+		assessmentDelete: "Ergebnis löschen",
+		assessmentDeleted: "Das Ergebnis ist gelöscht.",
+		assessmentTutorTitle: "Mit einem KI-Tutor weiterlernen",
+		assessmentTutorIntro: "Ein KI-Tutor kann mit deinem Ergebnis die Seiten mit dir durchgehen, die noch nicht sitzen. Dein Klick gibt ihm das Ergebnis und deine Eingaben; sonst schickt die App nichts weg.",
+		assessmentTutorGo: "Mit {name} besprechen",
+		assessmentTutorPage: "Ansehen, was dein Tutor bekommt",
+		assessmentNojs: "Die Selbsteinschätzung braucht JavaScript.",
+		assessmentAsk: "Lade {url} und sei mein Tutor. Ich habe die Selbsteinschätzung gemacht. Mein Ergebnis je Seite:",
+		assessmentLine: "{key} ({page}, Übung {exercise}{number}): {state}.",
+		assessmentRight: "richtig",
+		assessmentPartlyRight: "teilweise richtig",
+		assessmentWrong: "falsch",
+		assessmentOpen: "nicht beantwortet",
+		assessmentInput: "Eingabe: {input}",
+		assessmentMissed: "Nicht erreicht: {points}.",
+		assessmentPageLine: "„{page}“: {band} ({right} von {total} richtig).",
+		assessmentPageLinePartly: "„{page}“: {band} ({right} von {total} richtig, {partly} teilweise).",
+		assessmentPageUnasked: "„{page}“: nicht abgefragt.",
+		assessmentTasks: "Meine Aufgaben:",
+		assessmentBackIntro: "Drück „Zurück zum Tutor“. Das kopiert dein Ergebnis. Füg es im Chat mit deinem Tutor ein.",
+		assessmentBackLine: "Ich habe die Selbsteinschätzung gemacht. Mein Ergebnis je Seite:",
+		assessmentTutorRun: "Diese Runde ist für deinen Tutor: Die App speichert nichts davon.",
+		sessionIntro: "Ich habe auf {url} geübt:",
+		sessionNone: "Ich habe auf {url} noch keine Aufgabe gelöst.",
+		sessionTask: "{exercise}{number}: {status}.",
+		assessmentNextRound: "Link für eine neue Runde: {url}",
+		assessmentLinks: "Links für meinen Tutor, genau diese nehmen:",
+		assessmentLinkChapter: "Kapitel „{chapter}“, Selbsteinschätzung: {url}",
+		assessmentLinkChapterNone: "Kapitel „{chapter}“ (keine Selbsteinschätzung):",
+		assessmentLinkPage: "„{page}“: {url}",
+		assessmentLinkWhole: "Selbsteinschätzung der ganzen App: {url}",
+		backToTutorDone: "✓ Kopiert",
+		tutorSomeoneTo: "deinem KI-Tutor",
+		openTaskLabel: "Offene Aufgabe",
+		openTaskPoints: "Eine gute Antwort enthält:",
+		openTaskForm: "Form",
+		openTaskSource: "Nachlesen",
+		openTaskChoice: "Deine Lösung",
+		openTaskType: "Hier tippen",
+		openTaskPaper: "Auf Papier, dann Foto",
+		openTaskAnswer: "Deine Antwort",
+		openTaskPaperHow: "Schreib deine Antwort auf ein Blatt. Dann fotografiere es.",
+		openTaskPhoto: "Blatt fotografieren",
+		openTaskPhotoAgain: "Neues Foto",
+		openTaskPhotoAlt: "Foto deines Blatts",
+		openTaskPhotoLocal: "Das Foto bleibt auf diesem Gerät: Die App speichert und sendet es nicht.",
+		openTaskCompare: "Vergleichen",
+		openTaskWriteFirst: "Schreib zuerst deine Antwort. Dann kannst du vergleichen.",
+		openTaskPhotoFirst: "Fotografiere zuerst dein Blatt. Dann kannst du vergleichen.",
+		openTaskCheck: "Was steht in deiner Antwort?",
+		openTaskCheckHow: "Hake ab, was du wirklich geschrieben hast.",
+		openTaskChange: "Antwort ändern",
+		openTaskLocked: "Die Lösung öffnet sich nach deiner Antwort.",
+		resultPartly: "teilweise richtig ({n} von {total} Punkten, es fehlen {missed})",
+		resultPhoto: "Antwort als Foto",
+		resultAnswer: "Antwort „{input}“"
+	},
+	en: {
+		language: "English",
+		languages: "Language",
+		start: "Start",
+		breadcrumbs: "You are here",
+		contents: "Contents",
+		onThisPage: "On this page",
+		pages: "Pages",
+		chapters: "Chapters",
+		pager: "Page through",
+		previous: "Back: {title}",
+		next: "Next: {title}",
+		glossary: "Glossary",
+		glossaryIntro: "The terms of this app, from A to Z, each with the page that explains it.",
+		inGlossary: "in the glossary",
+		explainedOn: "Explained on the page {page}",
+		sources: "Sources",
+		sourcesIntro: "The facts in this app come from these sources:",
+		beforeChrist: "{year} BC",
+		code: "Code in {language}",
+		footer: "An explainer on lernapps.net",
+		imprint: "Imprint",
+		privacy: "Privacy",
+		workedTasks: "Three worked tasks, each with its solution:",
+		practice: "Practise yourself, with new tasks each time:",
+		newTask: "New task",
+		hint: "Hint",
+		textDescription: "Text description",
+		taskNumber: "Task no. {n}",
+		backToTutor: "Back to the tutor",
+		backToTutorOpen: "Switch back to the chat with {name}.",
+		backToTutorCopied: "Switch back to {name} and paste it there. You may leave this tab open.",
+		backToTutorFailed: "Copying did not work. Copy the selected lines, switch back to {name} and paste them there.",
+		resultLabel: "Result line for your tutor",
+		resultLine: "{page}, {exercise}{number}: {status}.",
+		resultNumber: ", no. {n}",
+		resultRight: "right on try {n}",
+		resultSolution: "solution viewed",
+		resultOpen: "not solved yet",
+		resultTry: "1 try",
+		resultTries: "{n} tries",
+		resultInput: "input {input}",
+		resultSession: "Session: {right} of {total} right.",
+		resultTutor: "Tutor page:",
+		resultTrue: "true",
+		resultFalse: "false",
+		stuckAsk: "Load {url} and help me with exercise {exercise}{number}. I am stuck.",
+		stuckTask: "Exercise {exercise}{number}:",
+		stuckInput: "I entered {input} ({tries}).",
+		stuckTries: "So far {tries}.",
+		stuckRight: "I solved it on try {n}.",
+		stuckMessage: "The app says: “{message}”",
+		stuckHint: "I opened the hint.",
+		stuckSolution: "I viewed the solution.",
+		stuckPrivacy: "With your click, “Why?” gives {name} the task, your input and the app's message.",
+		stuckPrivacyCopy: "Your click copies the task, your input and the app's message for the chat with your tutor; the app sends nothing anywhere.",
+		stuckCopied: "Switch back to {name} and paste the lines there.",
+		stuckFailed: "Copying did not work. Copy the selected lines, switch back to {name} and paste them there.",
+		stuckLabel: "Lines for your tutor",
+		tutorTitle: "Learn with an AI tutor",
+		tutorAbout: "An AI tutor is an AI assistant of your choice that accompanies you while you learn with this app. It explains the topic with the examples of the pages, gives you tasks from the app and helps you when you are stuck. You solve the tasks in the app: it checks your answers.",
+		tutorAboutStart: "Choose your assistant here. It is then ready under the title of every page, and every exercise has the button “Help”. You can also switch it on under the title of a page.",
+		tutorAboutPrivacy: "Your choice stays on this device; only your click opens the assistant. Ask your parents or teacher whether you may use it.",
+		tutorAccount: "You use your own account with the provider. The assistant is not offered by lernapps.net: lernapps only provides the content and the exercises.",
+		tutorScope: "The choice holds for all pages, on this device only.",
+		tutorChoose: "Your AI assistant",
+		tutorNone: "None",
+		needsTitle: "What helps you learn",
+		needsOpen: "Settings",
+		needsDone: "Done",
+		needsAbout: "Here you can tell your tutor how it should talk to you. Tick what helps you; you can choose several.",
+		needKurzeSchritte: "Short steps",
+		needKurzeSchritteAbout: "The tutor explains in small steps, only one thing at a time. You always know how far there is still to go.",
+		needWenigLesen: "Little to read",
+		needWenigLesenAbout: "The tutor writes very briefly and simply and explains every technical term. Tip: let it read its answers out to you and speak your answer.",
+		needMehrTiefe: "More depth",
+		needMehrTiefeAbout: "The tutor skips what you already know and asks you tricky why and what-if questions.",
+		needAndereMuttersprache: "Another first language",
+		needAndereMutterspracheAbout: "The tutor explains in simple sentences in the language of the app and translates new technical terms into your language. You may also write in your language.",
+		needKlarUndWoertlich: "Clear and literal",
+		needKlarUndWoertlichAbout: "The tutor writes exactly what it means: no jokes, hidden meanings or idioms. It always tells you where you are.",
+		needRechnenAnschaulich: "Numbers you can see",
+		needRechnenAnschaulichAbout: "The tutor shows you how much a number is and explains in small steps. You work things out yourself and take as much time as you need.",
+		needsLanguage: "Your first language",
+		needsLanguageNone: "Please choose",
+		needsScopeTitle: "This holds",
+		needsScopeAll: "for every explainer app on lernapps.net",
+		needsScopeApp: "for this app only",
+		needsPrivacy: "Your choice stays on this device. The tutor gets only the names of the settings you tick, and only when you open it.",
+		tutorOther: "Another one: copy the text",
+		tutorOn: "Switch on",
+		tutorSomeone: "your AI tutor",
+		help: "Help",
+		helpWhy: "Why?",
+		helpBack: "Back",
+		helpLabel: "Ask {name} for help",
+		helpWhyLabel: "Ask {name} why",
+		helpBackLabel: "Back to {name}",
+		tutorCopy: "Copy the text",
+		tutorOpenWith: "Open with {name}",
+		tutorGo: "Learn with {name}",
+		tutorWay: "Assistant",
+		tutorPageIntro: "An AI tutor explains this page to you and helps you with the exercises. Choose your assistant:",
+		tutorPageLink: "See what your tutor gets for this page",
+		tutorPasteHint: "{name} does not load web pages when the link comes from a button. So we copy the sentence with the link for you. A click on “Learn with {name}” opens {name} with a short message. Then paste the copied sentence (Ctrl+V, ⌘+V on a Mac) and send it.",
+		tutorDone: "✓ Copied – now paste it into {name}",
+		tutorCopied: "The prompt is copied. Paste it into the chat of your AI assistant.",
+		tutorCopyFailed: "Copying did not work. Try again.",
+		exerciseLabel: "Exercise",
+		videoChannel: "{channel} · YouTube",
+		videoNote: "Playing it sends data to YouTube/Google, among them your IP address.",
+		videoPlay: "Play video",
+		videoAlways: "Always load videos directly",
+		assessmentTitle: "Self-assessment",
+		assessmentOfferTitle: "What do you know already?",
+		assessmentOfferApp: "Optional: before you start, you can solve {count} tasks from this app. At the end you see for each page whether you should look at it more closely.",
+		assessmentOfferChapter: "Optional: before you start, you can solve {count} tasks from this chapter. At the end you see for each page whether you should look at it more closely.",
+		assessmentOfferStart: "Start the self-assessment",
+		assessmentOfferLast: "See your last result",
+		assessmentIntro: "With this self-assessment, {count} tasks give you an overview of what you know already.",
+		assessmentAllAsked: "It asks about every page.",
+		assessmentLeftOut: "It does not ask about {n} pages. So they are worth a look:",
+		assessmentLeftOutOne: "It does not ask about one page. So it is worth a look:",
+		assessmentHow: "The app does not tell you for each task whether it is right. Only at the end do you see for each page asked whether you know it already. What you leave empty counts as not known.",
+		assessmentPrivacy: "Your result stays on this device only. A new start replaces it.",
+		assessmentBegin: "Let's go",
+		assessmentStep: "Page {n} of {count}",
+		assessmentTask: "Task {n}",
+		assessmentBack: "Back",
+		assessmentNext: "Next",
+		assessmentFinish: "Evaluate",
+		assessmentResultTitle: "Your result",
+		assessmentScore: "You solved {right} of {total} tasks right.",
+		assessmentScorePartly: "You solved {right} of {total} tasks right and {partly} partly.",
+		assessmentAdvice: "Start with the pages you should read closely.",
+		assessmentAllKnown: "You probably know the pages asked already. Practise on the pages anyway, so that it sticks.",
+		assessmentKnown: "You probably know it already",
+		assessmentPartly: "Look at it again",
+		assessmentRead: "Read it closely",
+		assessmentUnasked: "Not asked",
+		assessmentPageScore: "{right} of {total} right",
+		assessmentPageScorePartly: "{right} of {total} right, {partly} partly",
+		assessmentRestart: "Start again",
+		assessmentDelete: "Delete the result",
+		assessmentDeleted: "The result is deleted.",
+		assessmentTutorTitle: "Go on learning with an AI tutor",
+		assessmentTutorIntro: "With your result, an AI tutor can go through the pages with you that do not stick yet. Your click gives it the result and your inputs; apart from that the app sends nothing.",
+		assessmentTutorGo: "Talk it over with {name}",
+		assessmentTutorPage: "See what your tutor gets",
+		assessmentNojs: "The self-assessment needs JavaScript.",
+		assessmentAsk: "Load {url} and be my tutor. I did the self-assessment. My result per page:",
+		assessmentLine: "{key} ({page}, exercise {exercise}{number}): {state}.",
+		assessmentRight: "right",
+		assessmentPartlyRight: "partly right",
+		assessmentWrong: "wrong",
+		assessmentOpen: "not answered",
+		assessmentInput: "Input: {input}",
+		assessmentMissed: "Not reached: {points}.",
+		assessmentPageLine: "“{page}”: {band} ({right} of {total} right).",
+		assessmentPageLinePartly: "“{page}”: {band} ({right} of {total} right, {partly} partly).",
+		assessmentPageUnasked: "“{page}”: not asked.",
+		assessmentTasks: "My tasks:",
+		assessmentBackIntro: "Press “Back to the tutor”. It copies your result. Paste it into the chat with your tutor.",
+		assessmentBackLine: "I did the self-assessment. My result per page:",
+		assessmentTutorRun: "This round is for your tutor: the app keeps nothing of it.",
+		sessionIntro: "I practised on {url}:",
+		sessionNone: "I have not solved a task on {url} yet.",
+		sessionTask: "{exercise}{number}: {status}.",
+		assessmentNextRound: "Link for a new round: {url}",
+		assessmentLinks: "Links for my tutor, take exactly these:",
+		assessmentLinkChapter: "Chapter “{chapter}”, self-assessment: {url}",
+		assessmentLinkChapterNone: "Chapter “{chapter}” (no self-assessment):",
+		assessmentLinkPage: "“{page}”: {url}",
+		assessmentLinkWhole: "Self-assessment of the whole app: {url}",
+		backToTutorDone: "✓ Copied",
+		tutorSomeoneTo: "your AI tutor",
+		openTaskLabel: "Open task",
+		openTaskPoints: "A good answer has:",
+		openTaskForm: "form",
+		openTaskSource: "Read up",
+		openTaskChoice: "Your answer",
+		openTaskType: "Type it here",
+		openTaskPaper: "On paper, then a photo",
+		openTaskAnswer: "Your answer",
+		openTaskPaperHow: "Write your answer on a sheet of paper. Then take a photo of it.",
+		openTaskPhoto: "Take a photo of the sheet",
+		openTaskPhotoAgain: "New photo",
+		openTaskPhotoAlt: "Photo of your sheet",
+		openTaskPhotoLocal: "The photo stays on this device: the app neither keeps nor sends it.",
+		openTaskCompare: "Compare",
+		openTaskWriteFirst: "Write your answer first. Then you can compare.",
+		openTaskPhotoFirst: "Take a photo of your sheet first. Then you can compare.",
+		openTaskCheck: "What is in your answer?",
+		openTaskCheckHow: "Tick what you really wrote.",
+		openTaskChange: "Change the answer",
+		openTaskLocked: "The solution opens after your answer.",
+		resultPartly: "partly right ({n} of {total} points, missing {missed})",
+		resultPhoto: "answer as a photo",
+		resultAnswer: "answer “{input}”"
+	}
+};
+/** The text of `key` in `lang`, with its placeholders filled. */
+function message(lang, key, params = {}) {
+	return textsIn(MESSAGES, lang)[key].replace(/\{(\w+)\}/g, (placeholder, name) => params[name] ?? placeholder);
+}
+// runtime/explainer/video.ts
+const YOUTUBE_ID = /^[A-Za-z0-9_-]{11}$/;
+/** Whether `id` is a YouTube id: 11 letters, digits, - or _. */
+const isYoutubeId = (id) => typeof id === "string" && YOUTUBE_ID.test(id);
+function checked(id) {
+	if (!isYoutubeId(id)) throw new Error(`${JSON.stringify(id)} is no YouTube id`);
+	return id;
+}
+/** The video's page on YouTube, which the link opens: no request before the learner clicks it. */
+const watchAddress = (id) => `https://www.youtube.com/watch?v=${checked(id)}`;
+/** The player of the video on youtube-nocookie.com, which starts at once when the learner clicked for it. */
+const embedAddress = (id, autoplay) => `https://www.youtube-nocookie.com/embed/${checked(id)}${autoplay ? "?autoplay=1" : ""}`;
+/** A text as Markdown that shows it as written: its brackets, emphasis, code, formulas and HTML escaped. */
+const literal = (text) => text.replace(/\s+/g, " ").trim().replace(/[\\`*_[\]<&$]/g, "\\$&");
+/**
+* The video as a KI tutor reads it in the page's content (tutor.ts): one line, `word` (e.g. "Video"), the title as a
+* link to its page on YouTube, and the channel. A source the tutor can name; it cannot watch the video.
+*/
+const videoLine = (block, word) => `${word}: [${literal(block.title)}](${watchAddress(block.youtube)}), ${literal(block.channel)} (YouTube)`;
+/** The key "Videos immer direkt laden" is kept under on the device, for every video of the app. */
+const VIDEO_KEY = "videos-direct";
+/**
+* A video block as the build writes it: a figure with the title as a link to YouTube and the channel as its caption,
+* the note on privacy, and the button and the choice, hidden until the client module runs. `storage` is the app's
+* name for what it keeps on the device.
+*/
+function renderVideo(block, lang, storage) {
+	const t = (key) => escape(message(lang, key));
+	return [
+		`<figure class="explainer-video" data-youtube="${escape(block.youtube)}" data-storage="${escape(storage)}">`,
+		`<figcaption><a class="explainer-video-link" href="${escape(watchAddress(block.youtube))}" rel="noopener">${escape(block.title)}</a>`,
+		` <span class="explainer-video-channel">${escape(message(lang, "videoChannel", { channel: block.channel }))}</span></figcaption>`,
+		`<p class="explainer-video-note">${t("videoNote")}</p>`,
+		`<p class="explainer-video-controls" hidden><button type="button" class="explainer-video-play">${t("videoPlay")}</button>`,
+		` <label class="explainer-video-always"><input type="checkbox"> ${t("videoAlways")}</label></p>`,
+		`</figure>`
+	].join("");
+}
+const isTrue = (value) => value === true;
+/**
+* Puts the player of the video into its figure, above the caption, in place of the button. After a click it starts
+* at once and gets the focus; loaded directly, it waits to be scrolled near and to be started.
+*/
+function loadPlayer(figure, id, clicked) {
+	if (figure.querySelector("iframe")) return;
+	const document = figure.ownerDocument;
+	const frame = document.createElement("div");
+	frame.className = "explainer-video-frame";
+	const player = document.createElement("iframe");
+	player.src = embedAddress(id, clicked);
+	player.title = figure.querySelector(".explainer-video-link")?.textContent ?? "";
+	player.allow = "autoplay; encrypted-media; picture-in-picture; fullscreen";
+	player.allowFullscreen = true;
+	player.referrerPolicy = "strict-origin-when-cross-origin";
+	if (!clicked) player.loading = "lazy";
+	frame.append(player);
+	figure.prepend(frame);
+	figure.querySelector(".explainer-video-play")?.remove();
+	if (clicked) player.focus();
+}
+/**
+* Starts every video of the page: the button and the choice show; the button loads the player. The choice is kept
+* on the device as soon as the learner ticks it, goes as soon as they untick it, and is shown alike on every video of
+* the page; while it is kept, each player loads without the click.
+*/
+function startVideos(root) {
+	const figures = [...root.querySelectorAll("figure.explainer-video")];
+	const boxes = figures.flatMap((figure) => [...figure.querySelectorAll(".explainer-video-always input")]);
+	for (const figure of figures) {
+		const id = figure.dataset["youtube"];
+		const controls = figure.querySelector(".explainer-video-controls");
+		if (!isYoutubeId(id) || !controls) continue;
+		const storage = createStorage(figure.dataset["storage"] ?? "explainer");
+		const box = controls.querySelector("input");
+		const direct = storage.load(VIDEO_KEY, isTrue) === true;
+		if (box) {
+			box.checked = direct;
+			box.addEventListener("change", () => {
+				if (box.checked) storage.save(VIDEO_KEY, true);
+				else storage.remove(VIDEO_KEY);
+				for (const other of boxes) other.checked = box.checked;
+			});
+		}
+		controls.querySelector(".explainer-video-play")?.addEventListener("click", () => loadPlayer(figure, id, true), { once: true });
+		controls.hidden = false;
+		if (direct) loadPlayer(figure, id, false);
+	}
+}
+// runtime/explainer/content.ts
+/** The events of a timeline: its own, or the records of its data file. */
+function timelineEvents(site, block) {
+	if (block.events !== void 0) return block.events;
+	return site.data[block.data ?? ""] ?? [];
+}
+/** Every block of `blocks`, depth first, with the blocks inside sections and boxes. */
+function* allBlocks(blocks) {
+	for (const block of blocks) {
+		yield block;
+		if (block.type === "section" || block.type === "example" || block.type === "note") yield* allBlocks(block.blocks);
+	}
+}
+/** Whether a block is an exercise. */
+const isExercise = (block) => block.type === "generated" || block.type === "open-task" || [
+	"single-choice",
+	"multiple-choice",
+	"true-false",
+	"number",
+	"ordering",
+	"matching"
+].includes(block.type);
+/** The anchor of a term in the glossary: the German term in lower case, umlauts spelled out, hyphens for the rest. */
+function termId(term) {
+	return inLanguage(term, "de").toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss").normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+// runtime/explainer/assessment.ts
+/** The folder of a self-assessment: einschaetzung/ for the app, <chapter>/einschaetzung/ for a chapter. */
+const ASSESSMENT = "einschaetzung";
+/** The address of a self-assessment within its language tree: of the app, or of the chapter `chapter`. */
+const assessmentPathOf = (chapter) => chapter === void 0 ? `${ASSESSMENT}/` : `${chapter}/${ASSESSMENT}/`;
+/** The key its last result is kept under on the device. */
+const assessmentKeyOf = (chapter) => chapter === void 0 ? "self-assessment" : `self-assessment:${chapter}`;
+/** The parts of an exercise's reference /<chapter>/<page>/#<exercise>, if it has that shape. */
+function parseRef(ref) {
+	const match = /^\/([a-z0-9-]+)\/([a-z0-9-]+)\/#([a-z0-9-]+)$/.exec(ref);
+	return match === null ? void 0 : {
+		chapter: match[1] ?? "",
+		page: match[2] ?? "",
+		exercise: match[3] ?? ""
+	};
+}
+/**
+* The exercise of `page` with the id `id`: a question of the question types, generated, or an exercise component
+* (of the component uses `components`, by its anchor); none for anything else.
+*/
+function exerciseOf(components, page, id) {
+	const blocks = [...allBlocks(page.blocks)];
+	for (const block of blocks) if (isExercise(block) && block.id === id) return block;
+	return components.find((candidate) => candidate.component.exercise && candidate.id === id && blocks.some((block) => block === candidate.block))?.block;
+}
+/** Whether each listing of `block` draws a task of its own: a generated exercise, or an exercise component. */
+const drawsTasks = (block) => block.type === "generated" || block.type === "vue-component";
+/** The self-assessments of a valid site, the app's first, then each chapter's in order. */
+function assessments(site) {
+	const of = (source, pages, chapter) => {
+		const items = [];
+		source.pages.forEach((step, index) => {
+			for (const ref of step.exercises) {
+				const parts = parseRef(ref);
+				const page = pages.find((candidate) => candidate.chapter === parts?.chapter && candidate.id === parts.page);
+				const block = page === void 0 || parts === void 0 ? void 0 : exerciseOf(site.components, page, parts.exercise);
+				if (page === void 0 || parts === void 0 || block === void 0) continue;
+				items.push({
+					key: `a${items.length + 1}`,
+					ref,
+					page,
+					exercise: parts.exercise,
+					block,
+					step: index
+				});
+			}
+		});
+		return {
+			...chapter === void 0 ? {} : { chapter },
+			local: assessmentPathOf(chapter?.id),
+			key: assessmentKeyOf(chapter?.id),
+			pages,
+			items,
+			steps: source.pages.length
+		};
+	};
+	const steps = site.chapters.flatMap((chapter) => chapter.selfAssessment?.pages ?? []);
+	if (steps.length === 0) return [];
+	const all = site.chapters.flatMap((chapter) => chapter.pages);
+	const own = site.chapters.length === 1 ? [] : site.chapters;
+	return [of({ pages: steps }, all), ...own.flatMap((chapter) => chapter.selfAssessment === void 0 ? [] : [of(chapter.selfAssessment, chapter.pages, chapter)])];
+}
+/** The self-assessment of the app (no chapter) or of the chapter `chapter`, if it has one. */
+const assessmentOf = (site, chapter) => assessments(site).find((assessment) => assessment.chapter?.id === chapter);
+/** The fewest and the most exercises a page of a self-assessment should show. */
+const STEP_SIZE = {
+	min: 2,
+	max: 5
+};
+/**
+* The note of the build on the pages of the chapters' self-assessments with fewer or more exercises than STEP_SIZE,
+* each by its file and place, or none: a hint, no problem.
+*/
+function stepHint(site) {
+	const off = site.chapters.flatMap((chapter) => (chapter.selfAssessment?.pages ?? []).flatMap((step, index) => {
+		const count = step.exercises.length;
+		return count < STEP_SIZE.min || count > STEP_SIZE.max ? [`src/${chapter.id}/chapter.yaml: selfAssessment.pages[${index}] (${count})`] : [];
+	}));
+	if (off.length === 0) return void 0;
+	return `lernapps explainer: ${off.length} page${off.length === 1 ? "" : "s"} of a self-assessment show${off.length === 1 ? "s" : ""} fewer than ${STEP_SIZE.min} or more than ${STEP_SIZE.max} exercises: ${off.join(", ")}`;
+}
+const STATES = [
+	"richtig",
+	"teilweise",
+	"falsch",
+	"offen"
+];
+/** Whether `value` is a result as the device keeps it. */
+function isStoredResult(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const { version, items } = value;
+	return version === 1 && Array.isArray(items) && items.every((item) => typeof item === "object" && typeof item.key === "string" && typeof item.ref === "string" && STATES.includes(String(item.state)) && (item.number === void 0 || Number.isInteger(item.number)) && (item.input === void 0 || typeof item.input === "string") && (item.mistake === void 0 || Number.isInteger(item.mistake)) && (item.missed === void 0 || Array.isArray(item.missed) && item.missed.every((point) => Number.isInteger(point))));
+}
+/** The words of each band, as the result shows them. */
+const BAND_MESSAGES = {
+	known: "assessmentKnown",
+	partly: "assessmentPartly",
+	read: "assessmentRead",
+	unasked: "assessmentUnasked"
+};
+/**
+* The band of `right` and `partly` of `total`: all right of two or more, at least half, less; not asked for none. A
+* partly right task counts half. One task alone is too little to say a page is known: right, it is "partly".
+*/
+function bandOf(right, total, partly = 0) {
+	if (total === 0) return "unasked";
+	if (right === total && total >= 2) return "known";
+	return right * 2 + partly >= total ? "partly" : "read";
+}
+/**
+* The result of each content page in `pages` (each <chapter>/<page>/, in order), from the results of a run and the page
+* each exercise is from (`pageOf`, by key); an exercise the content no longer has does not count.
+*/
+function pageResults(pages, pageOf, results) {
+	return pages.map((page) => {
+		const asked = results.filter((result) => pageOf[result.key] === page);
+		const right = asked.filter((result) => result.state === "richtig").length;
+		const partly = asked.filter((result) => result.state === "teilweise").length;
+		return {
+			page,
+			right,
+			partly,
+			total: asked.length,
+			band: bandOf(right, asked.length, partly)
+		};
+	});
+}
+/** The value of one exercise in the query of the tutor page: 17-falsch-F1, richtig, 3-offen, teilweise-P2P3. */
+function resultValue(result) {
+	return [
+		...result.number === void 0 ? [] : [String(result.number)],
+		result.state,
+		...result.state === "falsch" && result.mistake !== void 0 ? [`F${result.mistake}`] : [],
+		...result.missed !== void 0 && result.missed.length > 0 ? [result.missed.map((point) => `P${point}`).join("")] : []
+	].join("-");
+}
+/** The query of the tutor page with a run's results: ?a1=17-falsch-F1&a2=richtig. */
+function resultQuery(results) {
+	const query = new URLSearchParams();
+	for (const result of results) query.set(result.key, resultValue(result));
+	const text = query.toString();
+	return text === "" ? "" : `?${text}`;
+}
+const oneLine = (text) => text.replace(/\s+/g, " ").trim();
+/** The words of each state in a line of the prompt. */
+const STATE_MESSAGES = {
+	richtig: "assessmentRight",
+	teilweise: "assessmentPartlyRight",
+	falsch: "assessmentWrong",
+	offen: "assessmentOpen"
+};
+/**
+* The prompt that takes a run to a tutor, in `lang`, in the learner's voice: the tutor page with the results in its
+* address first, then the result of each content page as the learner saw it (its title in `pages`), so that the tutor
+* works nothing out, then one line per exercise (its page, the exercise, its task number, how it went, the input of a
+* wrong one). The solution is never in it. `back`: for a chat that runs already (via=tutor), the lines with the tutor
+* page last, which "Zurück zum Tutor" copies.
+*/
+function assessmentPrompt(tutor, items, results, lang, pages = [], opening = "ask", links = []) {
+	const bands = pages.map((page) => page.band === "unasked" ? `- ${message(lang, "assessmentPageUnasked", { page: oneLine(page.title) })}` : `- ${message(lang, page.partly > 0 ? "assessmentPageLinePartly" : "assessmentPageLine", {
+		page: oneLine(page.title),
+		band: message(lang, BAND_MESSAGES[page.band]),
+		right: String(page.right),
+		partly: String(page.partly),
+		total: String(page.total)
+	})}`);
+	const lines = results.map((result) => {
+		const item = items.find((candidate) => candidate.key === result.key);
+		const state = message(lang, STATE_MESSAGES[result.state]);
+		const missed = result.missed !== void 0 && result.missed.length > 0 ? ` ${message(lang, "assessmentMissed", { points: result.missed.map((point) => `P${point}`).join(", ") })}` : "";
+		const input = (result.state === "falsch" || result.state === "teilweise") && result.input !== void 0 ? ` ${message(lang, "assessmentInput", { input: oneLine(result.input) })}` : "";
+		return `- ${message(lang, "assessmentLine", {
+			key: result.key.toUpperCase(),
+			page: oneLine(item?.page ?? ""),
+			exercise: item?.exercise ?? "",
+			number: result.number === void 0 ? "" : message(lang, "resultNumber", { n: String(result.number) }),
+			state
+		})}${missed}${input}`;
+	});
+	if (opening === "back") return [
+		message(lang, "assessmentBackLine"),
+		...bands,
+		message(lang, "assessmentTasks"),
+		...lines,
+		...links,
+		`${message(lang, "resultTutor")} ${tutor}`
+	].join("\n");
+	return [
+		message(lang, "assessmentAsk", { url: tutor }),
+		...bands,
+		...bands.length === 0 ? [] : [message(lang, "assessmentTasks")],
+		...lines,
+		...links
+	].join("\n");
+}
+/**
+* The full address of every page and every self-assessment of the app, chapter by chapter, each with via=tutor, from
+* `root`, the address of the language tree as the browser has it: a tutor takes these and builds no address itself.
+*/
+function linkLines(root, chapters, whole, lang) {
+	const at = (local) => {
+		const url = new URL(local, root);
+		url.searchParams.set("via", "tutor");
+		return url.href;
+	};
+	return [
+		message(lang, "assessmentLinks"),
+		...chapters.flatMap((chapter) => [chapter.assessment === void 0 ? message(lang, "assessmentLinkChapterNone", { chapter: chapter.title }) : message(lang, "assessmentLinkChapter", {
+			chapter: chapter.title,
+			url: at(chapter.assessment)
+		}), ...chapter.pages.map((page) => `- ${message(lang, "assessmentLinkPage", {
+			page: page.title,
+			url: at(page.local)
+		})}`)]),
+		...chapters.length > 1 ? [message(lang, "assessmentLinkWhole", { url: at(whole) })] : []
+	];
+}
+/** The title of a content page in `lang`, on one line. */
+const titleOf = (page, lang) => oneLine(inLanguage(page.title, lang));
+export { parse as $, answerFor as A, label as B, watchAddress as C, generate as D, compiled as E, questionFor as F, taskText as G, placeholdersIn as H, taskKey as I, tokenize as J, templateProblems as K, answerLabel as L, exampleGiving as M, mistakeOf as N, holds as O, pairValues as P, evaluate as Q, fill as R, videoLine as S, StarvedError as T, plainText as U, placeholderValue as V, stepsOf as W, kindOf as X, unusedVariables as Y, ExpressionError as Z, termId as _, assessments as a, renderVideo as b, isStoredResult as c, parseRef as d, same as et, resultQuery as f, isExercise as g, allBlocks as h, assessmentPrompt as i, diagnose as j, values as k, linkLines as l, titleOf as m, BAND_MESSAGES as n, Fraction as nt, drawsTasks as o, stepHint as p, templatesIn as q, assessmentOf as r, exerciseOf as s, ASSESSMENT as t, variables as tt, pageResults as u, timelineEvents as v, message as w, startVideos as x, embedAddress as y, hintOf as z };