@lernapps/app-templates 0.2.0 → 0.3.0

package/README.md

@@ -21,7 +21,7 @@ feature: assistants read it before they choose an archetype.
 | Folder | Archetype | What the app supplies |
 |---|---|---|
 | [`quiz/`](quiz/) | a quiz about things to know: questions with options, feedback on every option, score and solutions, in one or more languages (a page per language) | the question bank `src/quiz.json` ([schema](runtime/quiz/quiz.v1.schema.json)) |
-| [`explainer/`](explainer/) | an explainer: chapters of pages with sections, formulas, figures, tables, timelines, definitions with a glossary, quotes, code and YouTube videos behind two clicks, and an exercise on every page (the quiz's question types, and `generated` exercises drawn from a seed and property-tested at build), readable without JavaScript, in one or more languages; an optional self-assessment of the app or a chapter, checked as a whole; Vue components for what no block can express | the content as YAML in `src/`: `app.yaml`, a folder per chapter with `chapter.yaml` and its pages, `data/` and `images/`, and `components/` ([schema](runtime/explainer/explainer.v1.schema.json)) |
+| [`explainer/`](explainer/) | an explainer: chapters of pages with sections, formulas, figures, tables, timelines, definitions with a glossary, quotes, code and YouTube videos behind two clicks, and an exercise on every page but a recap page (the quiz's question types, and `generated` exercises drawn from a seed and property-tested at build), readable without JavaScript, in one or more languages; an optional self-assessment of the app or a chapter, checked as a whole; Vue components for what no block can express | the content as YAML in `src/`: `app.yaml`, a folder per chapter with `chapter.yaml` and its pages, `data/` and `images/`, and `components/` ([schema](runtime/explainer/explainer.v2.schema.json); format 1: [schema](runtime/explainer/explainer.v1.schema.json)) |
 | [`interactive/`](interactive/) | an interactive app whose doing is the content (a game, a trainer): a static start page, readable without JavaScript, and an app page with the app's own Vue components, its routes as `app/#<id>`; the build plays its playthroughs against its core | `src/app.yaml` ([schema](runtime/interactive/interactive.v1.schema.json)), the core `src/core/index.ts` (`start(seed, route)`, `step(state, input)` with a key or an action of its root component, optional `tick(state, dt)`), its components in `src/ui/`, data in `src/data/`, and `src/playthroughs/*.yaml` ([schema](runtime/interactive/playthrough.v1.schema.json)) |
 
 - [`runtime/`](runtime/): the runtime of each archetype, published to npm as `@lernapps/app-templates` (with the template folders, complete example apps, and the scaffold of each archetype: `lernapps create` of `@lernapps/tooling` copies the paths `lernapps.scaffold.<archetype>` in [`package.json`](package.json) lists and the placeholder in [`scaffold/<archetype>/`](scaffold/), and leaves the example in the installed package; [`scripts/scaffold.ts`](scripts/scaffold.ts) writes the same for the CI job `scaffold`); its exports
@@ -29,14 +29,8 @@ feature: assistants read it before they choose an archetype.
   one by one, for other archetypes that embed them as exercises: `@lernapps/app-templates/quiz/question` (schema,
   validation, rendering, checker, messages; a question's texts may be maps by language), `startQuestion` of `@lernapps/app-templates/quiz` and the helpers of
   `@lernapps/app-templates/quiz/e2e`; [`test/fixtures/question-page/`](test/fixtures/question-page/) is a page built so.
-- The placeholders of the explainer's `generated` exercises are always two braces around a declared name or its
-  field, nothing else inside: `{{G}}`, `{{e.name}}`, `{{answer}}`, in prose and in formulas alike
-  (`$\frac{{{W}}}{{{G}}} \cdot 100 = {{answer}}$`). One brace is never a placeholder, so in a formula `G`, `{G}` and
-  `\frac{W}{G}` are letters; the only LaTeX form this reserves, a double group around a lone name, means the same as
-  the name alone. The build fails on a placeholder whose name `given` does not declare, on one brace or spaces where a
-  placeholder was meant in prose (`{G}`, `{{ G }}`), on a variable of `given` that nothing uses (no placeholder, and
-  no expression of the figure, answer or mistakes; `where` does not count), and on a placeholder left after filling in
-  ([`generated.ts`](runtime/explainer/generated.ts)).
+- How to write the explainer's `generated` exercises, with their placeholders, is in its
+  [schema](runtime/explainer/explainer.v1.schema.json) (`$defs/generated`).
 - An explainer's components are Vue single-file components in `src/components/<Name>.vue`, each with
   `<script setup lang="ts">`, typed props and its test `<Name>.test.ts`, used by a `vue-component` block with its
   `props` and a `nojs` text. The build renders each with Vue's server renderer into its island, `hidden` until it
@@ -188,8 +182,8 @@ positive list, `TEMPLATE_PATHS`: a path on no list runs the root checks only, an
 change scope and runs all of them for any code change, catches the rest; when it catches what the hook let through, add
 the path to the list. The fixture jobs run only in CI. The job `check` reports the overall result and is the check to
 require. A change reaches new apps once it is released ([`release.yml`](.github/workflows/release.yml): after a merge to `main`,
-semantic-release takes the version from the conventional commits, tags `v<version>` and publishes to npm with provenance) and lernapps/tooling depends on that version; Renovate moves existing apps. The package leaves out
-each template's `.gitignore`, which npm never ships: `prepack` stages it as `_gitignore` ([`scripts/pack-dotfiles.ts`](scripts/pack-dotfiles.ts)), and `lernapps create` writes it back.
+semantic-release takes the version from the conventional commits, tags `v<version>` and publishes to npm with provenance) and lernapps/tooling depends on that version; Renovate moves existing apps. Each template folder has
+its `.gitignore` also as `_gitignore`, because npm never ships a `.gitignore`; change both together.
 
 ## License
 

package/dist/{assessment-Dy359O1O.mjs → assessment-DaKsXUdj.mjs}

@@ -123,7 +123,15 @@ const FUNCTIONS = {
 		arity: 2,
 		field: 1
 	},
-	reverse: { arity: 1 }
+	reverse: { arity: 1 },
+	sqrt: { arity: 1 },
+	pow: { arity: 2 },
+	sin: { arity: 1 },
+	cos: { arity: 1 },
+	tan: { arity: 1 },
+	asin: { arity: 1 },
+	acos: { arity: 1 },
+	atan: { arity: 1 }
 };
 const KEYWORDS = /* @__PURE__ */ new Set([
 	"and",
@@ -444,6 +452,98 @@ function integer(value, what) {
 	if (!value.isInteger()) throw new ExpressionError(`${what} needs a whole number`);
 	return Number(value.n);
 }
+/** A real number that is no fraction, as the fraction of its first APPROXIMATION_PLACES decimals. */
+function approximate(value, what) {
+	if (!Number.isFinite(value)) throw new ExpressionError(`${what} has no result here`);
+	return Fraction.from(Number(value.toFixed(12)));
+}
+/** The square root of a whole number ≥ 0, if it is whole. */
+function wholeRoot(n) {
+	if (n < 2n) return n;
+	let x = BigInt(Math.floor(Math.sqrt(Number(n))));
+	while (x * x > n) x--;
+	while ((x + 1n) * (x + 1n) <= n) x++;
+	return x * x === n ? x : void 0;
+}
+function sqrt(x) {
+	if (x.n < 0n) throw new ExpressionError(`sqrt needs a number ≥ 0, not ${x.toNumber()}`);
+	const n = wholeRoot(x.n);
+	const d = wholeRoot(x.d);
+	return n !== void 0 && d !== void 0 ? Fraction.of(n, d) : approximate(Math.sqrt(x.toNumber()), "sqrt");
+}
+/** The largest exponent of pow: beyond it, a number has more digits than any exercise shows. */
+const MAX_EXPONENT = 1e3;
+function pow(x, n) {
+	if (n.isInteger()) {
+		const e = Number(n.n);
+		if (Math.abs(e) > MAX_EXPONENT) throw new ExpressionError(`pow takes an exponent from -${MAX_EXPONENT} to ${MAX_EXPONENT}`);
+		if (x.n === 0n && e < 0) throw new ExpressionError("pow(0, n) needs n ≥ 0: division by zero");
+		const power = Fraction.of(x.n ** BigInt(Math.abs(e)), x.d ** BigInt(Math.abs(e)));
+		return e < 0 ? Fraction.of(1).div(power) : power;
+	}
+	if (x.n < 0n) throw new ExpressionError("pow of a negative number needs a whole exponent");
+	return approximate(x.toNumber() ** n.toNumber(), "pow");
+}
+/** The angle `x` in degrees, brought into 0 ≤ x < 360 exactly. */
+function turn(x) {
+	const full = Fraction.of(360);
+	const quotient = x.div(full);
+	let floor = quotient.n / quotient.d;
+	if (quotient.n < 0n && quotient.n % quotient.d !== 0n) floor -= 1n;
+	return x.sub(full.mul(Fraction.of(floor)));
+}
+/** The sine of the angles 0°, 30°, 90°, … whose sine is rational, in degrees. */
+const EXACT_SINE = /* @__PURE__ */ new Map([
+	[0, Fraction.of(0)],
+	[30, Fraction.of(1, 2)],
+	[90, Fraction.of(1)],
+	[150, Fraction.of(1, 2)],
+	[180, Fraction.of(0)],
+	[210, Fraction.of(-1, 2)],
+	[270, Fraction.of(-1)],
+	[330, Fraction.of(-1, 2)]
+]);
+const RADIANS = Math.PI / 180;
+function sine(degrees) {
+	const angle = turn(degrees);
+	return (angle.isInteger() ? EXACT_SINE.get(Number(angle.n)) : void 0) ?? approximate(Math.sin(angle.toNumber() * RADIANS), "sin");
+}
+const cosine = (degrees) => sine(degrees.add(Fraction.of(90)));
+function tangent(degrees) {
+	const angle = turn(degrees);
+	if (cosine(angle).n === 0n) throw new ExpressionError(`tan(${degrees.toNumber()}) has no value: the cosine of the angle is 0`);
+	if (angle.isInteger() && [
+		45,
+		135,
+		225,
+		315
+	].includes(Number(angle.n))) return Fraction.of(Number(angle.n) % 180 === 45 ? 1 : -1);
+	const sin = sine(angle);
+	return sin.n === 0n ? sin : approximate(Math.tan(angle.toNumber() * RADIANS), "tan");
+}
+/** The inverse of sin, cos or tan in degrees: exact for the values of the angles of EXACT_SINE and of 45°. */
+function inverse(fn, x) {
+	if (fn !== "atan" && (x.compare(Fraction.of(-1)) < 0 || x.compare(Fraction.of(1)) > 0)) throw new ExpressionError(`${fn} needs a number from -1 to 1, not ${x.toNumber()}`);
+	const known = (fn === "asin" ? {
+		"-1": -90,
+		"-1/2": -30,
+		"0": 0,
+		"1/2": 30,
+		"1": 90
+	} : fn === "acos" ? {
+		"-1": 180,
+		"-1/2": 120,
+		"0": 90,
+		"1/2": 60,
+		"1": 0
+	} : {
+		"-1": -45,
+		"0": 0,
+		"1": 45
+	})[x.toString()];
+	if (known !== void 0) return Fraction.of(known);
+	return approximate((fn === "asin" ? Math.asin(x.toNumber()) : fn === "acos" ? Math.acos(x.toNumber()) : Math.atan(x.toNumber())) / RADIANS, fn);
+}
 function call(fn, args, env) {
 	const value = (index) => evaluate(args[index], env);
 	const field = () => args[1].name;
@@ -459,6 +559,14 @@ function call(fn, args, env) {
 			return [...asList(value(0), "sortBy")].sort((a, b) => order(fieldOf(a, name), fieldOf(b, name), "sortBy"));
 		}
 		case "reverse": return [...asList(value(0), "reverse")].reverse();
+		case "sqrt": return sqrt(asNumber(value(0), "sqrt"));
+		case "pow": return pow(asNumber(value(0), "pow"), asNumber(value(1), "pow"));
+		case "sin": return sine(asNumber(value(0), "sin"));
+		case "cos": return cosine(asNumber(value(0), "cos"));
+		case "tan": return tangent(asNumber(value(0), "tan"));
+		case "asin":
+		case "acos":
+		case "atan": return inverse(fn, asNumber(value(0), fn));
 		default: throw new ExpressionError(`${fn} is not a function of the expression language`);
 	}
 }
@@ -553,6 +661,10 @@ 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;
+/** A chemical formula whose whole argument is one placeholder: \ce{{{e.gl}}}. */
+const CHEM = new RegExp(String.raw`\\ce\{\{\{(${PATH})\}\}\}`, "g");
+/** The start of the token of a placeholder that is the whole argument of \ce: ⟦ce:e.gl⟧. */
+const CHEM_TOKEN = "ce:";
 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) {
@@ -583,9 +695,61 @@ function answerLabel(spec, task, lang) {
 	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⟧}}. */
+/**
+* A template's placeholders as tokens: {{G}} becomes ⟦G⟧, inside a formula ($…$) {\text{⟦G⟧}}; a chemical formula
+* whose whole argument is a placeholder, \ce{{{e.gl}}}, becomes {\text{⟦ce:e.gl⟧}}, which fill() replaces by the
+* formula the build set for the task's value (LanguageTemplates.chem).
+*/
 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}⟧`));
+	return text.replace(SEGMENT, (whole, math, prose) => math !== void 0 ? `$${math.replace(CHEM, (_chem, path) => `{\\text{⟦${CHEM_TOKEN}${path}⟧}}`).replace(PLACEHOLDER, (_placeholder, path) => `{\\text{⟦${path}⟧}}`)}$` : (prose ?? whole).replace(PLACEHOLDER, (_placeholder, path) => `⟦${path}⟧`));
+}
+/** The formulas of a template ($…$), as written. */
+const formulasIn = (text) => [...text.matchAll(SEGMENT)].flatMap((match) => match[1] === void 0 ? [] : [match[1]]);
+/** The placeholders that are the whole argument of a \ce in a formula of a template (\ce{{{e.gl}}}), by their path. */
+function chemPlaceholdersIn(text) {
+	return formulasIn(text).flatMap((math) => [...math.matchAll(CHEM)].map((match) => match[1] ?? ""));
+}
+/** The argument of each \ce and \pu of a formula, with its command; braces balanced. */
+function mhchemArguments(math) {
+	const found = [];
+	for (const match of math.matchAll(/\\(ce|pu)\s*\{/g)) {
+		const start = (match.index ?? 0) + match[0].length;
+		let depth = 1;
+		for (let at = start; at < math.length; at++) if (math[at] === "{") depth++;
+		else if (math[at] === "}" && --depth === 0) {
+			found.push({
+				command: `\\${match[1] ?? ""}`,
+				argument: math.slice(start, at)
+			});
+			break;
+		}
+	}
+	return found;
+}
+const WHOLE_PLACEHOLDER = new RegExp(String.raw`^\{\{${PATH}\}\}$`);
+/**
+* The problems of the placeholders in \ce and \pu of one template. A placeholder in \ce is its whole argument,
+* \ce{{{e.gl}}}, drawn from a finite list (oneOf, or pick: 1 from a list or a data file), so that the build can set
+* the formula of every value; \pu takes none.
+*/
+function chemProblems(text, given) {
+	const problems = [];
+	for (const math of formulasIn(text)) for (const { command, argument } of mhchemArguments(math)) {
+		if (placeholdersIn(argument).length === 0) continue;
+		if (command === "\\pu") problems.push(`\\pu{${argument}} has a placeholder inside; \\pu takes none: write the number before it, e.g. {{m}}\\,\\pu{g}`);
+		else if (!WHOLE_PLACEHOLDER.test(argument)) problems.push(`\\ce{${argument}} has a placeholder among other text; in \\ce a placeholder is the whole argument, \\ce{{{e.gl}}}: put the whole formula into one field of the data (gl: "2H2 + O2 -> 2H2O")`);
+	}
+	for (const path of chemPlaceholdersIn(text)) {
+		const root = path.split(".")[0] ?? "";
+		if (root === "answer") {
+			problems.push("\\ce{{{answer}}} is not possible: the build sets only the formulas of values drawn from a list; show the formula of a value of given");
+			continue;
+		}
+		const arbitrary = given[root];
+		if (arbitrary === void 0) continue;
+		if (arbitrary.oneOf === void 0 && !(arbitrary.from !== void 0 && arbitrary.pick === 1)) problems.push(`\\ce{{{${path}}}} needs one value from a list: draw ${root} with oneOf, or with pick: 1 from a list or a data file, so that the build can set the formula of each value`);
+	}
+	return problems;
 }
 /** The placeholders of a template, by their path (G, e.name, answer). */
 function placeholdersIn(text) {
@@ -647,7 +811,7 @@ function writtenTemplates(spec) {
 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) => ({
+		return [...placeholderProblems(text, new Set(declared)), ...chemProblems(text, spec.given)].map((message) => ({
 			path,
 			...lang === void 0 ? {} : { lang },
 			message
@@ -690,15 +854,23 @@ function placeholderValue(spec, task, path, lang) {
 	}
 }
 /** 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) => {
+function fill(template, spec, task, lang, mode = "html", chem = {}) {
+	return (mode === "html" ? template.replace(/<mtext>⟦([^⟧]+)⟧<\/mtext>/g, (_whole, token) => {
+		if (token.startsWith(CHEM_TOKEN)) {
+			const path = token.slice(3);
+			const value = placeholderValue(spec, task, path, lang);
+			if (value === void 0) return `<mtext>{{${escape(path)}}}</mtext>`;
+			return chem[value.text] ?? `<mtext>${escape(value.text)}</mtext>`;
+		}
+		const path = token;
 		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) => {
+	}) : template).replace(/⟦([^⟧]+)⟧/g, (_whole, token) => {
+		const path = token.startsWith(CHEM_TOKEN) ? token.slice(3) : token;
 		const value = placeholderValue(spec, task, path, lang);
 		if (value === void 0) return `{{${path}}}`;
 		return mode === "html" ? escape(value.text) : value.text;
@@ -711,16 +883,18 @@ const templatesIn = (templates, lang) => templates[lang] ?? templates["de"] ?? {
 };
 /** The task's text as HTML, in `lang`. */
 function taskText(spec, task, lang, templates) {
-	return fill(templatesIn(templates, lang).task, spec, task, lang);
+	const { task: text, chem } = templatesIn(templates, lang);
+	return fill(text, spec, task, lang, "html", chem);
 }
 /** 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));
+	const { steps, chem } = templatesIn(templates, lang);
+	return steps.map((step) => fill(step, spec, task, lang, "html", chem));
 }
 /** 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);
+	const { hint, chem } = templatesIn(templates, lang);
+	return hint === void 0 ? void 0 : fill(hint, spec, task, lang, "html", chem);
 }
 /** The text of HTML, as a learner reads it: tags left out, entities resolved, white space folded. */
 function plainText(html) {
@@ -1153,7 +1327,11 @@ const MESSAGES = {
 		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}“"
+		resultAnswer: "Antwort „{input}“",
+		recap: "Wiederholung",
+		recapText: "Diese Seite wiederholt etwas, das du schon können solltest. Üben kannst du es in anderen Apps: {link}",
+		recapLink: "Baustein auf der Lernlandkarte von lernapps.net",
+		recapNote: "Wiederholung"
 	},
 	en: {
 		language: "English",
@@ -1353,7 +1531,11 @@ const MESSAGES = {
 		openTaskLocked: "The solution opens after your answer.",
 		resultPartly: "partly right ({n} of {total} points, missing {missed})",
 		resultPhoto: "answer as a photo",
-		resultAnswer: "answer “{input}”"
+		resultAnswer: "answer “{input}”",
+		recap: "Recap",
+		recapText: "This page goes over something you should already know. You can practise it in other apps: {link}",
+		recapLink: "building block on the learning map of lernapps.net",
+		recapNote: "recap"
 	}
 };
 /** The text of `key` in `lang`, with its placeholders filled. */
@@ -1461,6 +1643,11 @@ function* allBlocks(blocks) {
 		if (block.type === "section" || block.type === "example" || block.type === "note") yield* allBlocks(block.blocks);
 	}
 }
+/** The page of a competency on the learning map of lernapps.net, from <subject>/<competency> (a recap page's recap). */
+function mapUrl(recap) {
+	const [subject = "", competency = ""] = recap.split("/");
+	return `https://lernapps.net/apps/map/${subject}/c/${competency}/`;
+}
 /** Whether a block is an exercise. */
 const isExercise = (block) => block.type === "generated" || block.type === "open-task" || [
 	"single-choice",
@@ -1532,9 +1719,10 @@ function assessments(site) {
 	};
 	const steps = site.chapters.flatMap((chapter) => chapter.selfAssessment?.pages ?? []);
 	if (steps.length === 0) return [];
-	const all = site.chapters.flatMap((chapter) => chapter.pages);
+	const asked = (pages) => pages.filter((page) => page.recap === void 0);
+	const all = asked(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)])];
+	return [of({ pages: steps }, all), ...own.flatMap((chapter) => chapter.selfAssessment === void 0 ? [] : [of(chapter.selfAssessment, asked(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);
@@ -1693,4 +1881,4 @@ function linkLines(root, chapters, whole, lang) {
 }
 /** 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 };
+export { writtenTemplates as $, items as A, chemPlaceholdersIn as B, videoLine as C, compiled as D, StarvedError as E, mistakeOf as F, placeholdersIn as G, hintOf as H, pairValues as I, taskText as J, plainText as K, questionFor as L, answerFor as M, diagnose as N, generate as O, exampleGiving as P, unusedVariables as Q, taskKey as R, startVideos as S, message as T, label as U, fill as V, placeholderValue as W, templatesIn as X, templateProblems as Y, tokenize as Z, mapUrl as _, assessments as a, variables as at, embedAddress as b, isStoredResult as c, parseRef as d, kindOf as et, resultQuery as f, isExercise as g, allBlocks as h, assessmentPrompt as i, same as it, values as j, holds as k, linkLines as l, titleOf as m, BAND_MESSAGES as n, evaluate as nt, drawsTasks as o, Fraction as ot, stepHint as p, stepsOf as q, assessmentOf as r, parse as rt, exerciseOf as s, ASSESSMENT as t, ExpressionError as tt, pageResults as u, termId as v, watchAddress as w, renderVideo as x, timelineEvents as y, answerLabel as z };

package/dist/{blocks-CxtCPAa5.mjs → blocks-D4SSGKuL.mjs}

@@ -1,7 +1,7 @@
 import { i as inLanguage, l as textsIn, n as escapeText, s as localeOf, t as escape } from "./html-mffkHGHh.mjs";
 import { n as markerOf } from "./block-BK_ohsH1.mjs";
-import { c as renderMarkdown, n as isUrl, s as renderInline, u as renderFormula } from "./check-CteIFN96.mjs";
-import "./validate-Bxy9NfB8.mjs";
+import { c as renderMarkdown, n as isUrl, s as renderInline, u as renderFormula } from "./check-BxZOZPic.mjs";
+import "./validate-CfFykN0M.mjs";
 import hljs from "highlight.js/lib/core";
 import bash from "highlight.js/lib/languages/bash";
 import c from "highlight.js/lib/languages/c";

package/dist/blocks.mjs

@@ -1,4 +1,4 @@
 import { i as materialIn, n as markerOf, r as materialImages, t as MATERIAL_TYPES } from "./block-BK_ohsH1.mjs";
-import { a as highlight, i as hundredGrid, n as renderMaterial, r as bar, t as renderCredit } from "./blocks-CxtCPAa5.mjs";
-import { n as checkMaterial, t as MATERIAL_DEFINITIONS } from "./validate-Bxy9NfB8.mjs";
+import { a as highlight, i as hundredGrid, n as renderMaterial, r as bar, t as renderCredit } from "./blocks-D4SSGKuL.mjs";
+import { n as checkMaterial, t as MATERIAL_DEFINITIONS } from "./validate-CfFykN0M.mjs";
 export { MATERIAL_DEFINITIONS, MATERIAL_TYPES, bar, checkMaterial, highlight, hundredGrid, markerOf, materialImages, materialIn, renderCredit, renderMaterial };

package/dist/{check-CteIFN96.mjs → check-BxZOZPic.mjs}

@@ -4,7 +4,8 @@ import { Marked } from "marked";
 // runtime/shared/text/formula.ts
 globalThis.temml = temml;
 await import("temml/contrib/mhchem/mhchem.js");
-const allowed = /* @__PURE__ */ new Set([
+/** The commands a formula may use (explainer.v1.schema.json, $defs/latex), besides ^, _, braces and parentheses. */
+const COMMANDS = [
 	"\\frac",
 	"\\cdot",
 	"\\times",
@@ -21,8 +22,61 @@ const allowed = /* @__PURE__ */ new Set([
 	"\\{",
 	"\\}",
 	"\\ce",
-	"\\pu"
-]);
+	"\\pu",
+	"\\ ",
+	"\\quad",
+	"\\qquad",
+	"\\Rightarrow",
+	"\\Leftrightarrow",
+	"\\left",
+	"\\right",
+	"\\sin",
+	"\\cos",
+	"\\tan",
+	"\\arcsin",
+	"\\arccos",
+	"\\arctan",
+	"\\circ",
+	...[
+		"alpha",
+		"beta",
+		"gamma",
+		"delta",
+		"varepsilon",
+		"epsilon",
+		"zeta",
+		"eta",
+		"theta",
+		"vartheta",
+		"iota",
+		"kappa",
+		"lambda",
+		"mu",
+		"nu",
+		"xi",
+		"pi",
+		"rho",
+		"sigma",
+		"tau",
+		"upsilon",
+		"varphi",
+		"phi",
+		"chi",
+		"psi",
+		"omega",
+		"Gamma",
+		"Delta",
+		"Theta",
+		"Lambda",
+		"Xi",
+		"Pi",
+		"Sigma",
+		"Phi",
+		"Psi",
+		"Omega"
+	].map((letter) => `\\${letter}`)
+];
+const allowed = new Set(COMMANDS);
 /** The commands of `tex` outside the arguments of \ce and \pu, which mhchem reads in its own notation. */
 function commands(tex) {
 	const found = [];
@@ -42,7 +96,7 @@ function commands(tex) {
 /** What is wrong with the formula `tex`, or undefined when it is in the command list and parses. */
 function formulaProblem(tex) {
 	const unknown = commands(tex).find((command) => !allowed.has(command));
-	if (unknown !== void 0) return `${unknown} is not in the formula command list; write the formula with the commands the schema lists ($defs/latex)`;
+	if (unknown !== void 0) return `${unknown} is not in the formula command list; use only these commands, besides ^, _, braces and parentheses: ${COMMANDS.map((command) => command === "\\ " ? "\\  (a space)" : command).join(", ")}`;
 	try {
 		temml.renderToString(tex, { throwOnError: true });
 		return;

package/dist/{content-DO6oEJxj.mjs → content-CAL0Nz1a.mjs}

@@ -1,4 +1,4 @@
-import { t as checkText } from "./check-CteIFN96.mjs";
+import { t as checkText } from "./check-BxZOZPic.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { LineCounter, isNode, parseDocument } from "yaml";

package/dist/explainer-e2e.mjs

@@ -1,10 +1,10 @@
-import { a as routes, d as templatesOf, f as workedTasks, l as renderExercise, n as loadSite, s as dataOf, u as taskSeeds } from "./load-RosvaPZf.mjs";
+import { a as routes, d as templatesOf, f as workedTasks, l as renderExercise, n as loadSite, s as dataOf, u as taskSeeds } from "./load--ovXqbNE.mjs";
 import { i as inLanguage } from "./html-mffkHGHh.mjs";
-import { a as inspect, c as renderMarkdown, l as renderWithFormulas } from "./check-CteIFN96.mjs";
+import { a as inspect, c as renderMarkdown, l as renderWithFormulas } from "./check-BxZOZPic.mjs";
 import { C as wrongAnswer, _ as questionIn, b as rightAnswer, f as missesRight, g as questionId, i as questionMessagesIn, n as answerText, w as wrongReasons } from "./render-GS1Htlu8.mjs";
 import { a as giveAnswer, i as expectMaterial, r as expectFeedbackInView, t as answerQuestion } from "./e2e-CU0n_unV.mjs";
-import { A as answerFor, C as watchAddress, D as generate, F as questionFor, G as taskText, I as taskKey, R as fill, U as plainText, X as kindOf, a as assessments, j as diagnose, m as titleOf, v as timelineEvents, w as message, y as embedAddress } from "./assessment-Dy359O1O.mjs";
-import { n as answerShown } from "./result-D_mmCVwN.mjs";
+import { J as taskText, K as plainText, L as questionFor, M as answerFor, N as diagnose, O as generate, R as taskKey, T as message, V as fill, a as assessments, b as embedAddress, et as kindOf, m as titleOf, w as watchAddress, y as timelineEvents } from "./assessment-DaKsXUdj.mjs";
+import { n as answerShown } from "./result-DphIWHDF.mjs";
 import { n as ASSESSMENT_TASK_EVENT, p as taskNumber, u as nextTaskNumber } from "./tasks-DADUYy52.mjs";
 import { expect, test } from "playwright/test";
 // runtime/explainer/outline.ts
@@ -94,7 +94,7 @@ function walk(site, blocks, lang, level, anchor, into) {
 		}
 		case "generated": {
 			const data = dataOf(block, site.data);
-			const templates = templatesOf(block, [lang]);
+			const templates = templatesOf(block, [lang], data);
 			const worked = workedTasks(block, data, templates, lang);
 			for (const item of worked) for (const html of [
 				item.task,