@lernapps/app-templates 0.0.0-stage → 0.1.0

package/dist/explainer.mjs

@@ -0,0 +1,1246 @@
+import { t as escape } from "./html-mffkHGHh.mjs";
+import { S as shuffled, a as renderQuestion, g as questionId, l as isComplete, u as isCorrect } from "./render-BJey0bwl.mjs";
+import { n as startQuestion, t as readAnswer } from "./engine-BqF2Vffn.mjs";
+import { D as generate, F as questionFor, G as taskText, N as mistakeOf, W as stepsOf, c as isStoredResult, f as resultQuery, i as assessmentPrompt, j as diagnose, l as linkLines, n as BAND_MESSAGES, u as pageResults, w as message, x as startVideos, z as hintOf } from "./assessment-By2GGTJC.mjs";
+import { i as sessionLines, n as answerShown, r as resultLine, t as Progress } from "./result-_eQcamoz.mjs";
+import { c as addressOf, d as numberFromAddress, f as randomTaskNumber, i as NEW_TASK_ICON, n as ASSESSMENT_TASK_EVENT, p as taskNumber, r as ASSESSMENT_UNPACKED_EVENT, s as SHOWN_EVENT, t as ASSESSMENT_ANSWER_EVENT, u as nextTaskNumber } from "./tasks-DADUYy52.mjs";
+import { a as isNeedsChoice, c as withNeeds, r as NEEDS_KEY, s as withLanguage } from "./needs-BzEahJ6X.mjs";
+import { moveFocus } from "@lernapps/tooling/a11y";
+import { createSettings, createStorage } from "@lernapps/tooling/storage";
+// runtime/explainer/open-task.ts
+const isKept = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const kept = value;
+	return (kept.way === "text" || kept.way === "photo") && typeof kept.text === "string" && Array.isArray(kept.ticked) && kept.ticked.every((index) => Number.isInteger(index)) && typeof kept.compared === "boolean";
+};
+/** The state of an open task as `ticked` of `total` points give it, and the points missed. */
+function openTaskState(ticked, total) {
+	const missed = Array.from({ length: total }, (_point, index) => index).filter((index) => !ticked.includes(index));
+	return {
+		state: ticked.length === total ? "richtig" : ticked.length === 0 ? "falsch" : "teilweise",
+		missed
+	};
+}
+/** Makes the open task in `element` live; returns what became of it so far. */
+function startOpenTask(element, data, options = {}) {
+	const { lang, id, points } = data;
+	const t = (key, params) => escape(message(lang, key, params));
+	const live = element.querySelector(".explainer-open-live");
+	const listed = element.querySelector(".explainer-open-points");
+	const solution = element.querySelector(":scope > details.explainer-solution");
+	const empty = () => ({
+		state: "offen",
+		ticked: [],
+		missed: [],
+		photo: false
+	});
+	if (!live) return { result: empty };
+	if (listed) listed.hidden = true;
+	if (solution) solution.hidden = true;
+	const both = data.answer.includes("text") && data.answer.includes("photo");
+	let way = data.answer.includes("text") ? "text" : "photo";
+	let text = "";
+	let photo;
+	let ticked = [];
+	let compared = false;
+	const storage = options.assessment ? void 0 : createStorage(element.dataset["storage"] ?? "explainer", { type: "sessionStorage" });
+	const key = `antwort:${element.ownerDocument.location.pathname}#${id}`;
+	const kept = storage?.load(key, isKept);
+	if (kept !== void 0 && data.answer.includes(kept.way)) {
+		({way, text, compared} = kept);
+		ticked = kept.ticked.filter((index) => index < points.length);
+		if (way === "photo") compared = false;
+	}
+	const keep = () => storage?.save(key, {
+		way,
+		text,
+		ticked,
+		compared
+	});
+	live.innerHTML = [
+		`<div class="explainer-open-write">`,
+		both ? [
+			`<fieldset class="explainer-open-choice"><legend>${t("openTaskChoice")}</legend>`,
+			`<label><input type="radio" name="${id}-way" value="text" checked> <span>${t("openTaskType")}</span></label>`,
+			`<label><input type="radio" name="${id}-way" value="photo"> <span>${t("openTaskPaper")}</span></label>`,
+			`</fieldset>`
+		].join("") : "",
+		`<div class="explainer-open-text"><label for="${id}-text">${t("openTaskAnswer")}</label>`,
+		`<textarea id="${id}-text" rows="6"></textarea></div>`,
+		`<div class="explainer-open-photo" hidden><p>${t("openTaskPaperHow")}</p>`,
+		`<label class="explainer-open-shoot"><input type="file" accept="image/*" capture="environment"> <span>${t("openTaskPhoto")}</span></label>`,
+		`<img class="explainer-open-preview" alt="${t("openTaskPhotoAlt")}" hidden>`,
+		`<p class="explainer-open-local"><small>${t("openTaskPhotoLocal")}</small></p></div>`,
+		`<p class="explainer-open-need" aria-live="polite"></p>`,
+		`<p class="explainer-open-locked"><small>${t("openTaskLocked")}</small></p>`,
+		`</div>`,
+		`<fieldset class="explainer-open-check" hidden><legend>${t("openTaskCheck")}</legend>`,
+		`<p>${t("openTaskCheckHow")}</p>`,
+		points.map((point, index) => `<label><input type="checkbox" value="${index}"> <span>${escape(point.text)}${point.kind === "form" ? ` <small>(${t("openTaskForm")})</small>` : ""}${point.href === void 0 ? "" : ` <a href="${escape(point.href)}">${t("openTaskSource")}</a>`}</span></label>`).join(""),
+		`</fieldset>`,
+		`<p class="question-actions">`,
+		`<button type="button" class="explainer-open-compare">${t("openTaskCompare")}</button>`,
+		` <button type="button" class="explainer-open-change" hidden>${t("openTaskChange")}</button>`,
+		`</p>`
+	].join("");
+	live.hidden = false;
+	element.dispatchEvent(new CustomEvent(SHOWN_EVENT, { bubbles: true }));
+	const part = (selector) => live.querySelector(selector);
+	const write = part(".explainer-open-write");
+	const textPart = part(".explainer-open-text");
+	const photoPart = part(".explainer-open-photo");
+	const field = part("textarea");
+	const file = part("input[type=\"file\"]");
+	const preview = part(".explainer-open-preview");
+	const shoot = part(".explainer-open-shoot span");
+	const need = part(".explainer-open-need");
+	const check = part(".explainer-open-check");
+	const compare = part(".explainer-open-compare");
+	const change = part(".explainer-open-change");
+	const ready = () => way === "text" ? text.trim() !== "" : photo !== void 0;
+	const current = () => {
+		const answer = way === "text" ? { text: text.trim() } : {};
+		if (!compared) return {
+			...empty(),
+			...answer,
+			photo: way === "photo" && photo !== void 0
+		};
+		return {
+			...openTaskState(ticked, points.length),
+			ticked: [...ticked],
+			...answer,
+			photo: way === "photo"
+		};
+	};
+	/** The step the learner is at: writing, or comparing. */
+	const show = () => {
+		if (textPart) textPart.hidden = way !== "text";
+		if (photoPart) photoPart.hidden = way !== "photo";
+		if (write) write.hidden = compared;
+		if (check) check.hidden = !compared;
+		if (compare) compare.hidden = compared;
+		if (solution) solution.hidden = !compared;
+		if (change) change.hidden = !compared;
+		if (need) need.textContent = compared || ready() ? "" : message(lang, way === "text" ? "openTaskWriteFirst" : "openTaskPhotoFirst");
+	};
+	for (const radio of live.querySelectorAll(".explainer-open-choice input")) radio.addEventListener("change", () => {
+		if (radio.checked) way = radio.value === "photo" ? "photo" : "text";
+		keep();
+		show();
+	});
+	field?.addEventListener("input", () => {
+		text = field.value;
+		keep();
+		show();
+	});
+	file?.addEventListener("change", () => {
+		const chosen = file.files?.[0];
+		if (!chosen) return;
+		if (photo !== void 0) URL.revokeObjectURL(photo);
+		photo = URL.createObjectURL(chosen);
+		if (preview) {
+			preview.src = photo;
+			preview.hidden = false;
+		}
+		if (shoot) shoot.textContent = message(lang, "openTaskPhotoAgain");
+		show();
+	});
+	compare?.addEventListener("click", () => {
+		if (!ready()) {
+			show();
+			if (need) moveFocus(need);
+			return;
+		}
+		compared = true;
+		keep();
+		show();
+		const legend = check?.querySelector("legend");
+		if (legend) moveFocus(legend);
+		options.onResult?.(current(), true);
+	});
+	change?.addEventListener("click", () => {
+		compared = false;
+		keep();
+		show();
+		if (field && way === "text") moveFocus(field);
+	});
+	for (const box of check?.querySelectorAll("input") ?? []) box.addEventListener("change", () => {
+		const index = Number(box.value);
+		ticked = box.checked ? [...ticked, index].sort((a, b) => a - b) : ticked.filter((one) => one !== index);
+		keep();
+		options.onResult?.(current(), false);
+	});
+	for (const radio of live.querySelectorAll(".explainer-open-choice input")) radio.checked = radio.value === way;
+	if (field) field.value = text;
+	for (const box of check?.querySelectorAll("input") ?? []) box.checked = ticked.includes(Number(box.value));
+	show();
+	return { result: current };
+}
+/** The names of the points at `indexes` (each from 0): P1, P2, … */
+const pointNames = (indexes) => indexes.map((index) => `P${index + 1}`).join(", ");
+// runtime/explainer/stuck.ts
+/** The exercise and its task number, in `lang`: "prozentwert-ueben, Nr. 27". */
+const taskOf = (stuck, lang) => ({
+	exercise: stuck.exercise,
+	number: stuck.number === void 0 ? "" : message(lang, "resultNumber", { n: String(stuck.number) })
+});
+/** What the learner did and was told, in `lang`. */
+function stateLines(state, lang) {
+	const tries = state.attempts === 1 ? message(lang, "resultTry") : message(lang, "resultTries", { n: String(state.attempts) });
+	const lines = [];
+	if (state.rightAt !== void 0) lines.push(message(lang, "stuckRight", { n: String(state.rightAt) }));
+	else if (state.input !== void 0) lines.push(message(lang, "stuckInput", {
+		input: state.input,
+		tries
+	}));
+	else if (state.attempts > 0) lines.push(message(lang, "stuckTries", { tries }));
+	if (state.rightAt === void 0 && state.message !== void 0) lines.push(message(lang, "stuckMessage", { message: state.message.replace(/\s+/g, " ").trim() }));
+	if (state.hint === true) lines.push(message(lang, "stuckHint"));
+	if (state.revealed) lines.push(message(lang, "stuckSolution"));
+	return lines;
+}
+/** The lines for a running chat (B2), in `lang`: the task, what the learner did and was told, the tutor page. */
+const stuckLines = (stuck, lang) => [
+	message(lang, "stuckTask", taskOf(stuck, lang)),
+	...stateLines(stuck.state, lang),
+	`${message(lang, "resultTutor")} ${stuck.tutor}`
+].join("\n");
+/** The prompt of a new chat (B1), in `lang`: the tutor page and the task in one sentence, then the lines. */
+const stuckPrompt = (stuck, lang) => [message(lang, "stuckAsk", {
+	url: stuck.tutor,
+	...taskOf(stuck, lang)
+}), ...stateLines(stuck.state, lang)].join("\n");
+// runtime/explainer/position.ts
+/** The anchor of the address `href`, decoded. */
+const anchorOf = (href) => decodeURIComponent(new URL(href).hash.slice(1));
+/**
+* The exercise the learner is at on the page at `href`: the one answered last, else the one the anchor names, else the
+* page's only exercise; none on a page with several and no such hint.
+*/
+function currentExercise(href, page, last) {
+	const anchor = anchorOf(href);
+	const byId = (id) => page.exercises.find((exercise) => exercise.id === id);
+	return byId(last) ?? byId(anchor) ?? (page.exercises.length === 1 ? page.exercises[0] : void 0);
+}
+/**
+* The query of the page's tutor page: the task number the address `href` holds of each exercise with numbers, in the
+* page's order, then the exercise `exercise` and the section `section`, each if any; "" for none of them.
+*/
+function tutorQuery(href, page, exercise, section) {
+	const query = new URLSearchParams();
+	for (const candidate of page.exercises) {
+		const n = candidate.numbered ? numberFromAddress(href, candidate.id) : void 0;
+		if (n !== void 0) query.set(candidate.id, String(n));
+	}
+	if (exercise !== void 0) query.set("uebung", exercise.id);
+	if (section !== void 0) query.set("abschnitt", section);
+	const text = query.toString();
+	return text === "" ? "" : `?${text}`;
+}
+/** Way A: the task numbers the address `href` holds of the page's exercises, for learning the page. */
+const pageQuery = (href, page) => tutorQuery(href, page, void 0, void 0);
+/** Way B: the page's task numbers at `href`, and the exercise `id` with its section. */
+function taskQuery(href, page, id) {
+	const exercise = page.exercises.find((candidate) => candidate.id === id);
+	return tutorQuery(href, page, exercise ?? {
+		id,
+		numbered: false
+	}, exercise?.section);
+}
+// runtime/explainer/assessment-client.ts
+/** The value of copying the text in the select of the ways. */
+const COPY$1 = "copy";
+/** The words of a band in the result. */
+const BAND = BAND_MESSAGES;
+/** The offer on the start page or a chapter's page: shown, and naming the last result when the device keeps one. */
+function startOffers(root) {
+	for (const offer of root.querySelectorAll(".explainer-assessment-offer")) {
+		const storage = createStorage(offer.dataset["storage"] ?? "explainer");
+		const link = offer.querySelector(".explainer-assessment-link");
+		const last = link?.dataset["last"];
+		if (link && last !== void 0 && storage.load(offer.dataset["key"] ?? "", isStoredResult) !== void 0) link.textContent = last;
+		offer.hidden = false;
+	}
+}
+/**
+* The options of a choice in an order of its own, new for each run, so that a second run asks the question, not the
+* place of its answer.
+*/
+function mix(place, question) {
+	if (question.type !== "single-choice" && question.type !== "multiple-choice") return;
+	const options = [...place.querySelectorAll(".question-option")];
+	const parent = options[0]?.parentElement;
+	if (!parent) return;
+	for (const index of shuffled(options.length, Math.floor(Math.random() * 2 ** 31))) {
+		const option = options[index];
+		if (option) parent.append(option);
+	}
+}
+/** A task number of 1 to `count`, at random, avoiding the numbers in `avoid` while others are left. */
+function drawNumber(count, avoid) {
+	const left = Array.from({ length: count }, (_n, index) => index + 1).filter((n) => avoid.every((set) => !set.has(n)));
+	return left.length === 0 ? randomTaskNumber(count) : left[Math.floor(Math.random() * left.length)] ?? 1;
+}
+/** The task numbers of the round before, by exercise (its ref), from the address's vorher=a1.28,a4.2. */
+function previousNumbers(href, items) {
+	const numbers = /* @__PURE__ */ new Map();
+	for (const pair of (new URL(href).searchParams.get("vorher") ?? "").split(",")) {
+		const [key, n] = pair.split(".");
+		const ref = items.find((item) => item.key === key)?.ref;
+		if (ref === void 0 || !Number.isInteger(Number(n))) continue;
+		numbers.set(ref, (numbers.get(ref) ?? /* @__PURE__ */ new Set()).add(Number(n)));
+	}
+	return numbers;
+}
+/** Puts what the build wrote for JavaScript into the page: each <template> of a self-assessment, in its place. */
+function unpack(root) {
+	for (const template of root.querySelectorAll("template.explainer-assessment-template")) template.replaceWith(root.importNode(template.content, true));
+	root.dispatchEvent(new CustomEvent(ASSESSMENT_UNPACKED_EVENT));
+}
+/** Starts the self-assessment's page, and the offers on the start page and the chapters' pages. */
+function startAssessment(root, ways) {
+	unpack(root);
+	startOffers(root);
+	const box = root.querySelector(".explainer-assessment");
+	const script = box?.querySelector("script.explainer-assessment-data");
+	if (!box || !script) return;
+	const data = JSON.parse(script.textContent ?? "{}");
+	const lang = root.documentElement.lang;
+	const t = (key, params) => message(lang, key, params);
+	const storage = ways.running ? void 0 : createStorage(data.storage);
+	const intro = box.querySelector(".explainer-assessment-intro");
+	const steps = [...box.querySelectorAll(".explainer-assessment-step")];
+	const result = box.querySelector(".explainer-assessment-result");
+	if (!intro || !result) return;
+	for (const nojs of root.querySelectorAll(".explainer-assessment-nojs")) nojs.hidden = true;
+	box.hidden = false;
+	box.addEventListener("submit", (event) => event.preventDefault());
+	const views = [
+		intro,
+		...steps,
+		result
+	];
+	const show = (view, focus) => {
+		for (const other of views) other.hidden = other !== view;
+		const heading = view.querySelector("h2");
+		if (focus && heading) moveFocus(heading);
+	};
+	const live = /* @__PURE__ */ new Map();
+	const answers = /* @__PURE__ */ new Map();
+	box.addEventListener(ASSESSMENT_ANSWER_EVENT, (event) => {
+		const key = event.target.closest(".explainer-assessment-item")?.dataset["key"];
+		const answer = event.detail;
+		if (key !== void 0) {
+			if (answer === null) answers.delete(key);
+			else answers.set(key, answer);
+		}
+	});
+	const element = (key) => box.querySelector(`.explainer-assessment-item[data-key="${key}"]`);
+	const before = previousNumbers(root.location.href, data.items);
+	/** A new run: a new task of each generated exercise, every answer empty, the options mixed, the first page. */
+	const begin = () => {
+		live.clear();
+		answers.clear();
+		const drawn = /* @__PURE__ */ new Map();
+		for (const item of data.items) {
+			const place = element(item.key);
+			if (!place) continue;
+			const exercise = item.data;
+			if (exercise.kind === "question") {
+				place.querySelector("form")?.reset();
+				mix(place, exercise.question);
+				live.set(item.key, { question: exercise.question });
+				continue;
+			}
+			if (exercise.kind === "open") {
+				const { result } = startOpenTask(place, {
+					...exercise,
+					id: item.key
+				}, { assessment: true });
+				live.set(item.key, { open: result });
+				continue;
+			}
+			const { seeds } = exercise;
+			const used = drawn.get(item.ref) ?? /* @__PURE__ */ new Set();
+			drawn.set(item.ref, used);
+			const number = drawNumber(Math.max(seeds.length, 1), [used, before.get(item.ref) ?? /* @__PURE__ */ new Set()]);
+			used.add(number);
+			place.dataset["number"] = String(number);
+			if (exercise.kind === "component") {
+				const component = place.querySelector(".explainer-component");
+				const seed = seeds[number - 1] ?? number;
+				if (component) {
+					component.dataset["seed"] = String(seed);
+					component.dispatchEvent(new CustomEvent(ASSESSMENT_TASK_EVENT, { detail: { seed } }));
+				}
+				live.set(item.key, {
+					component: true,
+					number
+				});
+				continue;
+			}
+			const { spec, templates } = exercise;
+			const task = generate(spec, seeds[number - 1] ?? number, exercise.data);
+			const question = {
+				...questionFor(spec, task, lang, templates),
+				id: item.key
+			};
+			const target = place.querySelector(".explainer-assessment-live");
+			if (target) target.innerHTML = renderQuestion(question, {
+				lang,
+				textHtml: taskText(spec, task, lang, templates)
+			});
+			mix(place, question);
+			live.set(item.key, {
+				question,
+				number,
+				mistake: (answer) => mistakeOf(spec, task, question, answer)
+			});
+		}
+		const first = steps[0];
+		if (first) show(first, true);
+	};
+	/** What became of each exercise of the run. */
+	const evaluate = () => data.items.map((item) => {
+		const run = live.get(item.key);
+		const form = element(item.key)?.querySelector("form");
+		const base = {
+			key: item.key,
+			ref: item.ref,
+			...run?.number === void 0 ? {} : { number: run.number }
+		};
+		if (run?.open !== void 0) {
+			const answer = run.open();
+			if (answer.state === "offen") return {
+				...base,
+				state: "offen"
+			};
+			return {
+				...base,
+				state: answer.state,
+				...answer.text === void 0 || answer.text === "" ? {} : { input: answer.text },
+				...answer.missed.length === 0 ? {} : { missed: answer.missed.map((point) => point + 1) }
+			};
+		}
+		if (run?.component === true) {
+			const answer = answers.get(item.key);
+			if (answer === void 0) return {
+				...base,
+				state: "offen"
+			};
+			if (answer.correct) return {
+				...base,
+				state: "richtig"
+			};
+			return {
+				...base,
+				state: answer.partly === true ? "teilweise" : "falsch",
+				...answer.answer === void 0 ? {} : { input: answer.answer },
+				...answer.mistake === void 0 || answer.partly === true ? {} : { mistake: answer.mistake + 1 },
+				...answer.missed === void 0 ? {} : { missed: answer.missed.map((point) => point + 1) }
+			};
+		}
+		if (!run?.question || !form) return {
+			...base,
+			state: "offen"
+		};
+		const answer = readAnswer(run.question, form);
+		if (!isComplete(run.question, answer)) return {
+			...base,
+			state: "offen"
+		};
+		if (isCorrect(run.question, answer)) return {
+			...base,
+			state: "richtig"
+		};
+		const mistake = run.mistake?.(answer);
+		return {
+			...base,
+			state: "falsch",
+			input: answerShown(run.question, answer, lang),
+			...mistake === void 0 ? {} : { mistake: mistake + 1 }
+		};
+	});
+	const score = result.querySelector(".explainer-assessment-score");
+	const advice = result.querySelector(".explainer-assessment-advice");
+	const list = result.querySelector(".explainer-assessment-pages");
+	const status = result.querySelector(".explainer-assessment-status");
+	let shown = [];
+	/** Shows the result of a run: the score, the advice, and each content page with its band. */
+	const showResult = (results, focus) => {
+		shown = results;
+		const pageOf = Object.fromEntries(data.items.map((item) => [item.key, item.page]));
+		const pages = pageResults(data.pages.map((page) => page.page), pageOf, results);
+		const right = results.filter((one) => one.state === "richtig").length;
+		const partly = results.filter((one) => one.state === "teilweise").length;
+		if (score) score.textContent = t(partly > 0 ? "assessmentScorePartly" : "assessmentScore", {
+			right: String(right),
+			partly: String(partly),
+			total: String(results.length)
+		});
+		if (advice) {
+			const open = pages.some((page) => page.band === "read" || page.band === "partly");
+			advice.textContent = t(open ? "assessmentAdvice" : "assessmentAllKnown");
+		}
+		if (list) list.replaceChildren(...pages.map((page) => {
+			const info = data.pages.find((candidate) => candidate.page === page.page);
+			const item = root.createElement("li");
+			item.className = "explainer-assessment-page";
+			item.dataset["band"] = page.band;
+			const link = root.createElement("a");
+			link.href = info?.href ?? "";
+			link.textContent = info?.title ?? page.page;
+			const band = root.createElement("strong");
+			band.textContent = t(BAND[page.band]);
+			item.append(link, " ", band);
+			if (page.total > 0) {
+				const count = root.createElement("span");
+				count.className = "explainer-assessment-count";
+				count.textContent = t(page.partly > 0 ? "assessmentPageScorePartly" : "assessmentPageScore", {
+					right: String(page.right),
+					partly: String(page.partly),
+					total: String(page.total)
+				});
+				item.append(" ", count);
+			}
+			return item;
+		}));
+		if (status) status.textContent = "";
+		show(result, focus);
+	};
+	const links = () => linkLines(new URL(data.root, root.location.href).href, data.chapters, data.whole, lang);
+	const promptItems = () => data.items.map((item) => ({
+		key: item.key,
+		page: data.pages.find((page) => page.page === item.page)?.title ?? item.page,
+		exercise: item.exercise
+	}));
+	const promptPages = () => pageResults(data.pages.map((page) => page.page), Object.fromEntries(data.items.map((item) => [item.key, item.page])), shown).map((page) => ({
+		...page,
+		title: data.pages.find((one) => one.page === page.page)?.title ?? page.page
+	}));
+	const select = result.querySelector(".explainer-assessment-way");
+	const go = result.querySelector(".explainer-assessment-go");
+	const said = result.querySelector(".explainer-assessment-tutor-status");
+	const hint = result.querySelector(".explainer-tutor-hint");
+	const tutorBox = result.querySelector(".explainer-assessment-tutor");
+	if (ways.running && tutorBox) {
+		const back = root.createElement("button");
+		back.type = "button";
+		back.className = "explainer-assessment-back-to-tutor";
+		back.textContent = t("backToTutor");
+		const intro = root.createElement("p");
+		intro.textContent = t("assessmentBackIntro");
+		const row = root.createElement("p");
+		row.append(back);
+		tutorBox.replaceChildren(intro, row);
+		back.addEventListener("click", () => {
+			const base = new URL(data.root, root.location.href);
+			const tutor = new URL(`${data.tutor}${resultQuery(shown)}`, base).href;
+			const next = new URL(root.location.href);
+			next.search = "";
+			next.hash = "";
+			next.searchParams.set("via", "tutor");
+			const numbers = shown.flatMap((one) => one.number === void 0 ? [] : [`${one.key}.${one.number}`]);
+			if (numbers.length > 0) next.searchParams.set("vorher", numbers.join(","));
+			const lines = assessmentPrompt(tutor, promptItems(), shown, lang, promptPages(), "back", links());
+			ways.back(`${lines}\n${t("assessmentNextRound", { url: next.href.replace(/%2C/g, ",") })}`, back, tutorBox, data.storage, data.ways);
+		});
+		result.querySelector(".explainer-assessment-delete")?.remove();
+		const privacy = root.querySelector(".explainer-assessment-privacy");
+		if (privacy) privacy.textContent = t("assessmentTutorRun");
+	} else if (select && go) {
+		const chosen = ways.chosen(data.storage, data.ways);
+		if (chosen !== void 0) select.value = chosen.url === void 0 ? COPY$1 : chosen.name;
+		const way = () => select.value === COPY$1 ? { name: COPY$1 } : data.ways.find((candidate) => candidate.name === select.value);
+		const label = () => {
+			const current = way();
+			go.textContent = current?.url === void 0 ? t("tutorCopy") : t("assessmentTutorGo", { name: current.name });
+			ways.hint(select, hint);
+		};
+		select.addEventListener("change", label);
+		label();
+		go.addEventListener("click", () => {
+			const href = root.location.href;
+			const base = new URL(data.root, href);
+			const needs = ways.needs(data.storage);
+			const tutor = new URL(`${data.tutor}${withNeeds(resultQuery(shown), needs)}`, base).href;
+			const prompt = () => withLanguage(assessmentPrompt(tutor, promptItems(), shown, lang, promptPages(), "ask", links()), needs, lang);
+			const copy = async () => {
+				try {
+					const response = await fetch(new URL(data.markdown, base).href);
+					if (response.ok) return `${prompt()}\n\n${(await response.text()).trimEnd()}\n`;
+				} catch {}
+				return prompt();
+			};
+			ways.open(way(), {
+				start: prompt,
+				copy,
+				placeholder: data.placeholder
+			}, (copied) => {
+				if (said) said.textContent = copied === void 0 ? "" : t(copied ? "tutorCopied" : "tutorCopyFailed");
+			});
+		});
+	}
+	box.querySelector(".explainer-assessment-begin")?.addEventListener("click", begin);
+	steps.forEach((step, index) => {
+		step.querySelector(".explainer-assessment-back")?.addEventListener("click", () => {
+			const before = steps[index - 1];
+			if (before) show(before, true);
+		});
+		step.querySelector(".explainer-assessment-next")?.addEventListener("click", () => {
+			const after = steps[index + 1];
+			if (after) show(after, true);
+		});
+		step.querySelector(".explainer-assessment-finish")?.addEventListener("click", () => {
+			const results = evaluate();
+			storage?.save(data.key, {
+				version: 1,
+				items: results
+			});
+			showResult(results, true);
+		});
+	});
+	result.querySelector(".explainer-assessment-restart")?.addEventListener("click", begin);
+	result.querySelector(".explainer-assessment-delete")?.addEventListener("click", () => {
+		storage?.remove(data.key);
+		show(intro, false);
+		const button = intro.querySelector(".explainer-assessment-begin");
+		if (button) button.focus();
+		const line = root.createElement("p");
+		line.className = "explainer-assessment-deleted";
+		line.setAttribute("role", "status");
+		line.textContent = t("assessmentDeleted");
+		intro.querySelector(".explainer-assessment-deleted")?.remove();
+		intro.prepend(line);
+	});
+	const kept = (storage?.load(data.key, isStoredResult))?.items.filter((one) => data.items.some((item) => item.key === one.key && item.ref === one.ref));
+	if (kept !== void 0 && kept.length > 0) showResult(kept, false);
+	else show(intro, false);
+}
+// runtime/explainer/explainer.ts
+/** Makes a generated exercise live: a task from a seed, checked by the shared questions, and "Neue Aufgabe". */
+function startGenerated(element, data, progress) {
+	const live = element.querySelector(".explainer-live");
+	if (!live) return;
+	const { spec, templates, lang, texts } = data;
+	for (const part of element.querySelectorAll(".explainer-worked-intro, .explainer-worked")) part.hidden = true;
+	const { seeds } = data;
+	const count = Math.max(seeds.length, 1);
+	const from = numberFromAddress(location.href, spec.id);
+	let number = from === void 0 ? randomTaskNumber(count) : taskNumber(from, count);
+	history.replaceState(history.state, "", addressOf(location.href, spec.id, number));
+	const show = (focus) => {
+		const task = generate(spec, seeds[number - 1] ?? number, data.data);
+		const question = questionFor(spec, task, lang, templates);
+		const hint = hintOf(spec, task, lang, templates);
+		const steps = stepsOf(spec, task, lang, templates);
+		live.innerHTML = [
+			`<p class="explainer-practice">${escape(texts.practice)}</p>`,
+			`<p class="explainer-task-number">${escape(texts.taskNumber.replace("{n}", String(number)))} <button type="button" class="explainer-new-task" aria-label="${escape(texts.newTask)}" title="${escape(texts.newTask)}">${NEW_TASK_ICON}</button></p>`,
+			renderQuestion(question, {
+				lang,
+				textHtml: taskText(spec, task, lang, templates),
+				...steps.length === 0 ? {} : { explanationHtml: `<ol class="explainer-steps">${steps.map((step) => `<li>${step}</li>`).join("")}</ol>` }
+			}),
+			hint === void 0 ? "" : `<details class="explainer-hint"><summary>${escape(texts.hint)}</summary><p>${hint}</p></details>`
+		].join("\n");
+		live.hidden = false;
+		const item = live.querySelector(`#${questionId(question)}`);
+		if (item) {
+			const shown = number;
+			startQuestion(item, question, {
+				lang,
+				retry: true,
+				diagnose: (answer) => diagnose(spec, task, question, answer, lang, templates),
+				onAnswer: (answer, right, said) => progress.answered(spec.id, shown, right, answerShown(question, answer, lang), said),
+				onReveal: () => progress.revealed(spec.id, shown)
+			});
+			const opened = live.querySelector("details.explainer-hint");
+			opened?.addEventListener("toggle", () => {
+				if (opened.open) progress.hinted(spec.id, shown);
+			});
+			const legend = item.querySelector("legend");
+			if (focus && legend) moveFocus(legend);
+		}
+		element.dispatchEvent(new CustomEvent(SHOWN_EVENT, { bubbles: true }));
+		live.querySelector(".explainer-new-task")?.addEventListener("click", () => {
+			number = nextTaskNumber(number, count);
+			history.replaceState(history.state, "", addressOf(location.href, spec.id, number));
+			show(true);
+		});
+	};
+	show(false);
+}
+/** Whether a tutor opened the page: via=tutor in its address, exactly so. */
+const fromTutor = (href) => new URL(href).searchParams.get("via") === "tutor";
+/** The event an island sends for an exercise component's answer (islands.ts), with { correct, answer?, message? }. */
+const ANSWERED_EVENT = "explainer-answered";
+/** How long the button says "kopiert" after a copy. */
+const DONE_MS = 8e3;
+/** The data of the page's tutor section, if it has one. */
+function tutorData(root) {
+	const script = root.querySelector(".explainer-tutor script.explainer-tutor-prompt");
+	return script ? JSON.parse(script.textContent ?? "{}") : void 0;
+}
+/** Whether `text` is now on the clipboard. */
+async function copyText(text) {
+	try {
+		await navigator.clipboard.writeText(text);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** The absolute address of the page's tutor page with `query`, from the page at `href`. */
+const tutorAddress = (href, data, query) => new URL(`${data.tutor ?? ""}${query}`, new URL(data.root, href)).href;
+/**
+* `prompt` with the Markdown of the page's tutor page after it, for an assistant that fetches nothing: the app's own
+* static file; the prompt alone when it is not reachable, as it names the tutor page.
+*/
+async function withMarkdown(prompt, data, href) {
+	if (data.markdown === void 0) return prompt;
+	try {
+		const response = await fetch(new URL(data.markdown, new URL(data.root, href)).href);
+		if (response.ok) return `${prompt}\n\n${(await response.text()).trimEnd()}\n`;
+	} catch {}
+	return prompt;
+}
+/**
+* The result line of the page at `href` (result.ts): of the exercise `id`, else of the one the learner answered last,
+* else the one the anchor names, else the page's first; with the absolute address of the page's tutor page with the
+* position.
+*/
+function resultOf(href, lang, data, progress, id) {
+	const { page, tutor } = data;
+	const exercise = page === void 0 ? void 0 : page.exercises.find((candidate) => candidate.id === id) ?? currentExercise(href, page, progress.last) ?? page.exercises[0];
+	if (page === void 0 || exercise === void 0 || tutor === void 0) return void 0;
+	const n = exercise.numbered ? numberFromAddress(href, exercise.id) : void 0;
+	return resultLine({
+		page: page.title,
+		exercise: exercise.id,
+		...n === void 0 ? {} : { number: n },
+		state: progress.state(exercise.id, n),
+		session: progress.session(),
+		tutor: tutorAddress(href, data, taskQuery(href, page, exercise.id))
+	}, lang);
+}
+/**
+* Copies `text` for the running chat with the tutor ("Zurück zum Tutor", "Hilfe" and "Zurück" on a page a tutor
+* opened, via=tutor): the tab stays open, as closing it let the browser show some other tab; `button` says "✓ Kopiert"
+* for a while, as the tutor bar does after copying, and `status`, on a line below it, where to paste it. When
+* copying fails, the text is selected in `field` to copy by hand. The text goes to the clipboard only, never over the
+* network.
+*/
+function copyForChat(root, text, button, status, field, texts) {
+	const lang = root.documentElement.lang;
+	status.textContent = "";
+	copyText(text).then((copied) => {
+		if (!copied) {
+			field.value = text;
+			field.hidden = false;
+			field.focus();
+			field.select();
+			status.textContent = texts.failed;
+			return;
+		}
+		field.hidden = true;
+		status.textContent = texts.copied;
+		const before = [...button.childNodes];
+		button.dataset["done"] = "";
+		button.textContent = message(lang, "backToTutorDone");
+		setTimeout(() => {
+			if (button.dataset["done"] === void 0) return;
+			delete button.dataset["done"];
+			button.replaceChildren(...before);
+		}, DONE_MS);
+	});
+}
+/** A status line and the field for copying by hand, hidden until copying fails. */
+function statusAndField(root, label) {
+	const status = root.createElement("span");
+	status.setAttribute("role", "status");
+	status.setAttribute("aria-live", "polite");
+	const field = root.createElement("textarea");
+	field.className = "explainer-back-line";
+	field.readOnly = true;
+	field.rows = 3;
+	field.hidden = true;
+	field.setAttribute("aria-label", label);
+	return {
+		status,
+		field
+	};
+}
+/**
+* What "Zurück zum Tutor" copies on the page at `href`: the page's tutor page with the page's task numbers, and each
+* task the learner did in this session with how it went (result.ts, sessionLines).
+*/
+function sessionOf(href, lang, data, progress) {
+	const { page, tutor } = data;
+	if (page === void 0 || tutor === void 0) return void 0;
+	return sessionLines(tutorAddress(href, data, pageQuery(href, page)), progress.tasks(), progress.session(), lang);
+}
+/**
+* "Zurück zum Tutor" at the top and at the end of a page a tutor opened (via=tutor): it copies the page's tutor page
+* and how each task of the session went, for the running chat (copyForChat).
+*/
+function startBackToTutor(root, main, data, progress) {
+	const lang = root.documentElement.lang;
+	for (const at of ["top", "end"]) {
+		const box = root.createElement("p");
+		box.className = `explainer-back explainer-back-${at}`;
+		const button = root.createElement("button");
+		button.type = "button";
+		button.textContent = message(lang, "backToTutor");
+		const { status, field } = statusAndField(root, message(lang, "resultLabel"));
+		button.addEventListener("click", () => {
+			const lines = data === void 0 ? void 0 : sessionOf(root.location.href, lang, data, progress);
+			const name = chatName(data, lang);
+			if (lines === void 0) {
+				status.textContent = message(lang, "backToTutorOpen", { name });
+				return;
+			}
+			copyForChat(root, lines, button, status, field, {
+				copied: message(lang, "backToTutorCopied", { name }),
+				failed: message(lang, "backToTutorFailed", { name })
+			});
+		});
+		box.append(button, " ", status, field);
+		if (at === "top") main.prepend(box);
+		else main.append(box);
+	}
+}
+/**
+* Opens the assistant `provider` with the start prompt, when its address takes one; else copies the prompt to copy and
+* opens the assistant (none for copying the text), and `say` tells whether copying worked. A way that needs pasting
+* copies only the start prompt, at once, and its address gets only the placeholder message. The window opens at the click, which a browser
+* allows; the address follows once the prompt is copied.
+*/
+function openAssistant(root, provider, prompts, say) {
+	const template = provider?.url;
+	const paste = provider?.paste === true;
+	if (template !== void 0 && template.includes("{prompt}") && !paste) {
+		say(void 0);
+		root.defaultView?.open(template.split("{prompt}").join(encodeURIComponent(prompts.start())), "_blank", "noopener");
+		return;
+	}
+	const copied = paste ? copyText(prompts.start()) : void 0;
+	const opened = template === void 0 ? null : root.defaultView?.open("", "_blank");
+	if (opened) opened.opener = null;
+	Promise.resolve(copied ?? prompts.copy()).then(async (full) => {
+		say(typeof full === "boolean" ? full : await copyText(full));
+		if (template === void 0) return;
+		const address = paste ? template.split("{prompt}").join(encodeURIComponent(prompts.placeholder)) : template;
+		if (opened) opened.location.href = address;
+		else root.defaultView?.open(address, "_blank", "noopener");
+	});
+}
+/** The key the switched-on way to the tutor is kept under on the device: an assistant's name, or COPY; none when off. */
+const WAY_KEY = "tutor-way";
+const COPY = "copy";
+const isText = (value) => typeof value === "string";
+/**
+* The way to the tutor the learner switched on, kept on the device (@lernapps/tooling/storage), one per app: on the
+* start page or under the title of a page. Whoever shows something of it listens, so that switching it on or off shows
+* at once on the whole page.
+*/
+var WayChoice = class {
+	#storage;
+	#ways;
+	#listeners = [];
+	constructor(storage, ways) {
+		this.#storage = createStorage(storage);
+		this.#ways = ways;
+	}
+	/** The way switched on, if any: an assistant the app still offers, or copying. */
+	get() {
+		const name = this.#storage.load(WAY_KEY, isText);
+		if (name === COPY) return { name: COPY };
+		return this.#ways.find((way) => way.name === name);
+	}
+	/** Switches the way `name` on (an assistant's name, or COPY), or the tutor off. */
+	set(name) {
+		if (name === void 0) this.#storage.remove(WAY_KEY);
+		else this.#storage.save(WAY_KEY, name);
+		for (const listener of this.#listeners) listener();
+	}
+	listen(listener) {
+		this.#listeners.push(listener);
+	}
+};
+/** The archetype whose settings the needs are: they hold for every explainer, or for one app (dec-tutor-needs). */
+const ARCHETYPE = "explainer";
+/** The needs the learner chose for the tutor (needs.ts), for this app or for every explainer, if any. */
+const chosenNeeds = (storage) => createSettings(storage, ARCHETYPE).load(NEEDS_KEY, isNeedsChoice)?.value;
+/**
+* The name of the running chat's assistant, as "zurück zu …" says it: the one the learner switched on, else "deinem
+* KI-Tutor".
+*/
+function chatName(data, lang) {
+	const way = data === void 0 ? void 0 : new WayChoice(data.storage, data.ways).get();
+	return way?.url === void 0 ? message(lang, "tutorSomeoneTo") : way.name;
+}
+/** The name of a way as the page says it: the assistant's, or "deinen KI-Tutor" for copying. */
+const nameOf = (way, lang) => way?.url === void 0 ? message(lang, "tutorSomeone") : way.name;
+/** The symbol of a way: the first letter of the assistant's name in a circle, "?" for copying. */
+function iconOf(root, way) {
+	const icon = root.createElement("span");
+	icon.className = "explainer-ki-icon";
+	icon.setAttribute("aria-hidden", "true");
+	icon.textContent = way?.url === void 0 ? "?" : (way.name.trim()[0] ?? "?").toUpperCase();
+	return icon;
+}
+/**
+* The tutor's help button in every exercise of the page, way B, there only while a way to the tutor is switched on or
+* on a page a tutor opened (via=tutor). It sits in the row of "Prüfen" and "Lösung" (or below an exercise component,
+* outside its island),
+* with the assistant's symbol, and says what helps now: "Hilfe" before an answer and after the right one; "Warum?",
+* standing out, after a wrong one, with a sentence that says what the click gives the assistant; on a page a tutor
+* opened, "Zurück" once the task is right or its solution shown. "Hilfe" and "Warum?" give the lines of the task as the
+* learner has it now (stuck.ts): the task, the input with the tries, the app's message word for word, the hint or
+* solution opened, the page's tutor page with the task (taskQuery). B1, without a chat: they open the way switched
+* on, the tutor page and the task in one sentence first. B2, on a page a tutor opened: they copy the lines, and the
+* button says where to paste them (copyForChat), so the running chat goes on; "Zurück" copies the result line of the
+* task the same way.
+*/
+function startHelp(root, data, progress, choice) {
+	const { page, tutor } = data;
+	if (page === void 0 || tutor === void 0) return;
+	const lang = root.documentElement.lang;
+	const running = fromTutor(root.location.href);
+	const updates = /* @__PURE__ */ new Map();
+	for (const exercise of page.exercises) {
+		const element = root.getElementById(exercise.id);
+		if (!element) continue;
+		const button = root.createElement("button");
+		button.type = "button";
+		button.className = "explainer-help";
+		const label = root.createElement("span");
+		const own = root.createElement("p");
+		own.className = "explainer-help-row";
+		const note = root.createElement("p");
+		note.className = "explainer-help-note";
+		const text = root.createElement("small");
+		const { status, field } = statusAndField(root, message(lang, "stuckLabel"));
+		note.append(text, " ", status, field);
+		const place = () => {
+			const row = element.classList.contains("explainer-component") ? element.querySelector(":scope > form.explainer-component-form > .question-actions") : element.querySelector(".question-actions");
+			if (row) {
+				row.append(" ", button);
+				own.remove();
+			} else {
+				own.append(button);
+				element.append(own);
+			}
+			element.append(note);
+		};
+		const n = () => exercise.numbered ? numberFromAddress(root.location.href, exercise.id) : void 0;
+		let mode = "help";
+		const update = () => {
+			const way = choice.get();
+			const shown = running || way !== void 0;
+			button.hidden = !shown;
+			own.hidden = !shown;
+			const state = progress.state(exercise.id, n());
+			const done = state.rightAt !== void 0 || state.revealed;
+			mode = running && done ? "back" : state.attempts > 0 && !done ? "why" : "help";
+			const name = running ? message(lang, "tutorSomeone") : nameOf(way, lang);
+			label.textContent = message(lang, mode === "back" ? "helpBack" : mode === "why" ? "helpWhy" : "help");
+			button.setAttribute("aria-label", message(lang, mode === "back" ? "helpBackLabel" : mode === "why" ? "helpWhyLabel" : "helpLabel", { name }));
+			button.replaceChildren(iconOf(root, way), label);
+			button.classList.toggle("explainer-help-why", mode === "why");
+			button.classList.toggle("explainer-help-back", mode === "back");
+			text.textContent = mode !== "why" ? "" : running ? message(lang, "stuckPrivacyCopy") : message(lang, "stuckPrivacy", { name });
+			note.hidden = !shown || mode !== "why" && field.hidden && status.textContent === "";
+		};
+		const stuck = () => {
+			const href = root.location.href;
+			const number = n();
+			return {
+				exercise: exercise.id,
+				...number === void 0 ? {} : { number },
+				state: progress.state(exercise.id, number),
+				tutor: tutorAddress(href, data, running ? taskQuery(href, page, exercise.id) : withNeeds(taskQuery(href, page, exercise.id), chosenNeeds(data.storage)))
+			};
+		};
+		button.addEventListener("click", () => {
+			note.hidden = false;
+			if (mode === "back") {
+				const name = chatName(data, lang);
+				const line = resultOf(root.location.href, lang, data, progress, exercise.id);
+				if (line === void 0) status.textContent = message(lang, "backToTutorOpen", { name });
+				else copyForChat(root, line, button, status, field, {
+					copied: message(lang, "backToTutorCopied", { name }),
+					failed: message(lang, "backToTutorFailed", { name })
+				});
+				return;
+			}
+			if (running) {
+				const name = chatName(data, lang);
+				copyForChat(root, stuckLines(stuck(), lang), button, status, field, {
+					copied: message(lang, "stuckCopied", { name }),
+					failed: message(lang, "stuckFailed", { name })
+				});
+				return;
+			}
+			const way = choice.get();
+			const prompt = () => withLanguage(stuckPrompt(stuck(), lang), chosenNeeds(data.storage), lang);
+			const copy = () => withMarkdown(prompt(), data, root.location.href);
+			openAssistant(root, way, {
+				start: prompt,
+				copy,
+				placeholder: data.placeholder
+			}, (copied) => {
+				status.textContent = copied === void 0 ? "" : copied ? data.copied : data.failed;
+			});
+		});
+		place();
+		update();
+		element.addEventListener(SHOWN_EVENT, () => {
+			place();
+			update();
+		});
+		updates.set(exercise.id, update);
+	}
+	progress.listen((id) => updates.get(id)?.());
+	choice.listen(() => {
+		for (const update of updates.values()) update();
+	});
+}
+/** Shows in `hint` how the chosen option works when it says so (data-hint, a way that needs pasting); else hides it. */
+function showHint(select, hint) {
+	if (!hint) return;
+	const text = select.selectedOptions[0]?.dataset["hint"] ?? "";
+	hint.textContent = text;
+	hint.hidden = text === "";
+}
+/**
+* The choice of the learner's assistant on the start page: "Keiner", the app's assistants and copying the text, shown
+* once the client module runs; a choice is kept on the device at once (WayChoice), "Keiner" switches the tutor off.
+*/
+function startChoice(root) {
+	const select = root.querySelector("select.explainer-tutor-choose");
+	const box = select?.closest(".explainer-tutor-choice");
+	if (!select || !box) return;
+	const storage = createStorage(select.dataset["storage"] ?? "explainer");
+	const stored = storage.load(WAY_KEY, isText);
+	const names = [...select.options].map((option) => option.value);
+	select.value = stored !== void 0 && names.includes(stored) ? stored : "";
+	const hint = box.nextElementSibling instanceof HTMLElement ? box.nextElementSibling : null;
+	const explain = () => showHint(select, hint);
+	select.addEventListener("change", () => {
+		if (select.value === "") storage.remove(WAY_KEY);
+		else storage.save(WAY_KEY, select.value);
+		explain();
+	});
+	explain();
+	box.hidden = false;
+}
+/**
+* The choice of the learner's needs on the start page (dec-tutor-needs), put into the page from its <template>:
+* "Einstellungen" beside the choice of the assistant opens a dialog with a box per need, the first language once `andere-muttersprache` is ticked, and whether
+* the choice holds for every explainer or for this app only; each change is kept on the device at once as a setting
+* (createSettings), where the learner said.
+*/
+function startNeeds(root) {
+	const template = root.querySelector("template.explainer-tutor-needs-template");
+	template?.replaceWith(root.importNode(template.content, true));
+	const box = root.querySelector("dialog.explainer-tutor-needs");
+	const open = root.querySelector("button.explainer-tutor-needs-open");
+	if (!box || !open) return;
+	open.addEventListener("click", () => box.showModal());
+	const settings = createSettings(box.dataset["storage"] ?? "explainer", ARCHETYPE);
+	const boxes = [...box.querySelectorAll("input.explainer-tutor-need")];
+	const scopes = [...box.querySelectorAll("input.explainer-tutor-needs-scope")];
+	const language = box.querySelector("select.explainer-tutor-language");
+	const languageBox = language?.closest(".explainer-tutor-language-choice");
+	const stored = settings.load(NEEDS_KEY, isNeedsChoice);
+	for (const input of boxes) input.checked = stored?.value.needs.includes(input.value) === true;
+	const where = stored?.scope === "app" ? "app" : "archetype";
+	for (const input of scopes) input.checked = input.value === where;
+	if (language) {
+		const tags = [...language.options].map((option) => option.value);
+		const tag = stored?.value.language;
+		language.value = tag !== void 0 && tags.includes(tag) ? tag : "";
+	}
+	const showLanguage = () => {
+		if (languageBox) languageBox.hidden = !boxes.some((input) => input.checked && input.value === "andere-muttersprache");
+	};
+	const save = () => {
+		const needs = boxes.filter((input) => input.checked).map((input) => input.value);
+		const tag = language?.value ?? "";
+		const choice = {
+			needs,
+			...tag !== "" && needs.includes("andere-muttersprache") ? { language: tag } : {}
+		};
+		const scope = scopes.find((input) => input.checked)?.value === "app" ? "app" : "archetype";
+		settings.save(NEEDS_KEY, choice, scope);
+		showLanguage();
+	};
+	box.addEventListener("change", save);
+	showLanguage();
+}
+/**
+* "Mit einem KI-Tutor lernen", way A, beside the title of a content page. While no way is switched on, it stays
+* folded; unfolded, a select of the app's assistants and copying the text, and "Einschalten", which keeps the way on
+* the device (WayChoice). Once a way is on, a bar takes its place: "Mit <name> lernen", with the assistant's symbol;
+* the start page changes the way or switches it off. The bar's button does the way: it opens the assistant with the
+* start prompt in its address, the page's tutor page with the page's task numbers (prompt.ts, pageQuery), for a
+* tutor who leads through the page before it comes to a task; or it copies the prompt with the tutor page's Markdown, and opens
+* an assistant whose address takes no prompt. On a page a tutor opened (via=tutor) the chat runs already: the section
+* stays hidden. Nothing goes over the network but the click's own page, the tutor page's Markdown (the app's own
+* static file, for copying) and the assistant that opens.
+*/
+function startTutor(root, data, choice) {
+	const section = root.querySelector(".explainer-tutor");
+	if (!section) return;
+	if (fromTutor(root.location.href)) {
+		section.hidden = true;
+		return;
+	}
+	const off = section.querySelector("details.explainer-tutor-off");
+	const bar = section.querySelector(".explainer-tutor-bar");
+	const way = section.querySelector(".explainer-tutor-way");
+	const select = section.querySelector(".explainer-tutor-select");
+	const on = section.querySelector(".explainer-tutor-on");
+	const go = section.querySelector(".explainer-tutor-go");
+	const status = section.querySelector(".explainer-tutor-status");
+	if (!off || !bar || !way || !select || !on || !go) return;
+	let reset;
+	const done = root.createElement("span");
+	done.className = "explainer-tutor-go-done";
+	const say = (text, state) => {
+		clearTimeout(reset);
+		bar.toggleAttribute("data-done", state === "ok");
+		if (state === "ok") go.append(done);
+		else done.remove();
+		if (!status) return;
+		status.textContent = text;
+		if (state === void 0) delete status.dataset["state"];
+		else status.dataset["state"] = state;
+		if (state === "ok") reset = setTimeout(() => say(""), DONE_MS);
+	};
+	way.hidden = false;
+	const hint = section.querySelector(".explainer-tutor-hint");
+	select.addEventListener("change", () => showHint(select, hint));
+	showHint(select, hint);
+	const plain = section.querySelector(".explainer-tutor-plain");
+	if (plain) plain.hidden = true;
+	const show = () => {
+		const chosen = choice.get();
+		off.hidden = chosen !== void 0;
+		bar.hidden = chosen === void 0;
+		if (chosen === void 0) return;
+		const text = root.createElement("span");
+		text.className = "explainer-tutor-go-text";
+		text.textContent = chosen.url === void 0 ? data.copy : data.go.replace("{name}", chosen.name);
+		done.textContent = data.done.replace("{name}", nameOf(chosen, root.documentElement.lang));
+		go.replaceChildren(iconOf(root, chosen), text);
+	};
+	show();
+	choice.listen(show);
+	on.addEventListener("click", () => {
+		off.open = false;
+		choice.set(select.value);
+		say("");
+		go.focus();
+	});
+	const tree = new URL(data.root, root.location.href).href;
+	/** The start prompt: the page's tutor page with the page's task numbers and the learner's needs. */
+	const start = () => {
+		const text = data.start.split(data.base).join(tree);
+		const { page } = data;
+		const needs = chosenNeeds(data.storage);
+		const query = withNeeds(page === void 0 ? "" : pageQuery(root.location.href, page), needs);
+		return withLanguage(text.split(data.query).join(query), needs, root.documentElement.lang);
+	};
+	const whole = () => withMarkdown(start(), data, root.location.href);
+	go.addEventListener("click", () => {
+		openAssistant(root, choice.get(), {
+			start,
+			copy: whole,
+			placeholder: data.placeholder
+		}, (copied) => {
+			say(copied === void 0 ? "" : copied ? data.copied : data.failed, copied === void 0 ? void 0 : copied ? "ok" : "failed");
+		});
+	});
+}
+/** Starts the explainer on the page. */
+function startExplainer(root = document) {
+	root.documentElement.classList.add("explainer-js");
+	const main = root.querySelector("main");
+	const tutor = tutorData(root);
+	const progress = new Progress();
+	const assessment = root.querySelector(".explainer-assessment-nojs") !== null;
+	if (main && fromTutor(root.location.href) && !assessment) startBackToTutor(root, main, tutor, progress);
+	startChoice(root);
+	startNeeds(root);
+	if (tutor !== void 0) {
+		const choice = new WayChoice(tutor.storage, tutor.ways);
+		startTutor(root, tutor, choice);
+		startHelp(root, tutor, progress, choice);
+	}
+	root.addEventListener(ANSWERED_EVENT, (event) => {
+		const element = event.target;
+		const detail = event.detail;
+		if (!(element instanceof HTMLElement) || element.id === "" || detail === null) return;
+		const text = (value) => typeof value === "string" ? value : void 0;
+		progress.answered(element.id, numberFromAddress(root.location.href, element.id), detail.correct === true, text(detail.answer), text(detail.message));
+	});
+	startVideos(root);
+	startAssessment(root, {
+		chosen: (storage, ways) => new WayChoice(storage, ways).get(),
+		needs: chosenNeeds,
+		open: (way, prompts, say) => openAssistant(root, way, prompts, say),
+		hint: showHint,
+		running: fromTutor(root.location.href),
+		back: (text, button, place, storage, ways) => {
+			const lang = root.documentElement.lang;
+			const { status, field } = statusAndField(root, message(lang, "resultLabel"));
+			place.querySelector(":scope > .explainer-assessment-back-status")?.remove();
+			const line = root.createElement("p");
+			line.className = "explainer-assessment-back-status";
+			line.append(status, field);
+			place.append(line);
+			const name = chatName({
+				storage,
+				ways
+			}, lang);
+			copyForChat(root, text, button, status, field, {
+				copied: message(lang, "backToTutorCopied", { name }),
+				failed: message(lang, "backToTutorFailed", { name })
+			});
+		}
+	});
+	for (const script of root.querySelectorAll("script.explainer-exercise-data")) {
+		const element = script.parentElement;
+		if (!element) continue;
+		const data = JSON.parse(script.textContent ?? "{}");
+		if (data.kind === "question") {
+			const item = element.querySelector(".question");
+			if (!item) continue;
+			const solution = element.querySelector(":scope > details.explainer-solution");
+			if (solution) solution.hidden = true;
+			const { rendered, question, lang } = data;
+			const id = element.id;
+			startQuestion(item, question, {
+				lang,
+				retry: true,
+				format: (text) => rendered[text] ?? escape(text),
+				onAnswer: (answer, right, said) => progress.answered(id, void 0, right, answerShown(question, answer, lang), said),
+				onReveal: () => progress.revealed(id, void 0)
+			});
+		} else if (data.kind === "open") {
+			const { id, lang, points } = data;
+			startOpenTask(element, data, { onResult: (result, attempt) => progress.compared(id, result.ticked.length, points.length, pointNames(result.missed), result.photo ? message(lang, "resultPhoto") : shortened(result.text ?? ""), attempt) });
+		} else startGenerated(element, data, progress);
+	}
+}
+/** How much of an open answer a result line carries: the rest is the learner's to paste, if the tutor asks. */
+const ANSWER_IN_LINE = 2e3;
+/** An open answer on one line, at most ANSWER_IN_LINE characters. */
+const shortened = (text) => {
+	const line = text.replace(/\s+/g, " ").trim();
+	return line.length <= ANSWER_IN_LINE ? line : `${line.slice(0, ANSWER_IN_LINE)} …`;
+};
+export { ANSWERED_EVENT, fromTutor, startExplainer };