@lernapps/app-templates 0.0.1 → 0.1.1

package/dist/validate-BDwL7Su3.mjs

@@ -0,0 +1,1076 @@
+import { c as textLanguages } from "./html-mffkHGHh.mjs";
+import { n as checkMaterial, t as MATERIAL_DEFINITIONS } from "./validate-Bxy9NfB8.mjs";
+import { _ as questionIn, h as questionAddresses, l as isComplete, m as parseNumber, u as isCorrect, v as questionTexts, x as rightEntries } from "./render-GS1Htlu8.mjs";
+import { Ajv2020 } from "ajv/dist/2020.js";
+// runtime/shared/examples.ts
+/**
+* What to do about an example the check judges otherwise than it is listed: `right`, whether the check accepts it;
+* `check`, what judges it; `fix`, what to change so that the check agrees.
+*/
+function verdict(example, right, check = "the check", fix = "change the exercise so that its check") {
+	return right ? `${check} accepts ${example}, but it is listed as rejected; if the task's text rules it out, ${fix} rejects it, else move it to accepted` : `${check} rejects ${example}, but it is listed as accepted; if the task's text allows it, ${fix} accepts it, else move it to rejected`;
+}
+// runtime/shared/schema.ts
+/** The schemas the given ones are made of, by their $id. */
+const schemasById = (...schemas) => Object.fromEntries(schemas.map((schema) => [schema.$id, schema]));
+/**
+* The properties of the definition `name` of the schema `id`, and of everything it refers to; with `branches` false
+* not those of the branches of its allOf (the fields that only one type of a question has).
+*/
+function knownProperties(schemas, id, name, { branches = true } = {}) {
+	const into = /* @__PURE__ */ new Set();
+	const visit = (definition, scope) => {
+		if (typeof definition !== "object" || definition === null) return;
+		const def = definition;
+		for (const key of Object.keys(def.properties ?? {})) into.add(key);
+		if (typeof def.$ref === "string") {
+			const [target = "", fragment = ""] = def.$ref.split("#");
+			const there = target === "" ? scope : target;
+			const found = (schemas[there]?.$defs)?.[fragment.replace("/$defs/", "")];
+			visit(found, there);
+		}
+		for (const part of def.allOf ?? []) {
+			const branch = typeof part === "object" && part !== null && "then" in part;
+			if (branch && !branches) continue;
+			visit(part, scope);
+			if (branch) visit(part.then, scope);
+		}
+	};
+	visit((schemas[id]?.$defs)?.[name], id);
+	return into;
+}
+// runtime/shared/blocks/blocks.v1.schema.json
+var blocks_v1_schema_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "urn:lernapps:schema:blocks.v1",
+	title: "Blocks that show content",
+	description: "The blocks the quiz shows with a question and the explainer shows on a page alike: prose, a formula, a figure (drawn from data or a bundled image), a labelled figure (a bundled image with numbered labels), a table, a quotation and program code, with the credit of an image or a quotation. An image is a file in src/images/ of the app.",
+	$defs: {
+		"credit": {
+			"description": "Where a bundled image or a quote comes from: the source (a URL or a citation) and its licence (an SPDX identifier such as CC-BY-SA-4.0, or \"gemeinfrei\").",
+			"type": "object",
+			"properties": {
+				"source": {
+					"description": "Where it comes from: a URL, the same in every language and shown as a link, or a citation, a text like any other: a string while German is the only language of the app, else a map of texts by language with every declared language, e.g. { de: eigene Zeichnung, en: own drawing }. Each language's page shows its own.",
+					"anyOf": [{
+						"type": "string",
+						"minLength": 1,
+						"pattern": "\\S"
+					}, {
+						"type": "object",
+						"minProperties": 1,
+						"propertyNames": { "pattern": "^[a-z]{2}$" },
+						"additionalProperties": {
+							"type": "string",
+							"minLength": 1,
+							"pattern": "\\S"
+						}
+					}]
+				},
+				"licence": {
+					"description": "Its licence: an SPDX identifier (CC-BY-SA-4.0, CC0-1.0, …), or gemeinfrei for a work in the public domain.",
+					"type": "string",
+					"minLength": 1,
+					"pattern": "\\S"
+				}
+			}
+		},
+		"image": {
+			"description": "A bundled image file in src/images/, as a path from src/: images/<name>.svg (or .png, .jpg, .webp).",
+			"type": "string",
+			"pattern": "^images/[a-z0-9]+(-[a-z0-9]+)*\\.(svg|png|jpg|webp)$"
+		},
+		"drawing": {
+			"description": "A figure drawn from numbers at build, as inline SVG: hundred-grid (a field of 100 squares, filled of them shaded) or bar (a strip, part of whole shaded, with its percentage).",
+			"type": "object",
+			"required": ["kind"],
+			"properties": { "kind": { "enum": ["hundred-grid", "bar"] } },
+			"allOf": [{
+				"if": {
+					"properties": { "kind": { "const": "hundred-grid" } },
+					"required": ["kind"],
+					"type": "object"
+				},
+				"then": {
+					"required": ["filled"],
+					"properties": { "filled": {
+						"description": "How many of the 100 squares are shaded.",
+						"type": "integer",
+						"minimum": 0,
+						"maximum": 100
+					} },
+					"type": "object"
+				}
+			}, {
+				"if": {
+					"properties": { "kind": { "const": "bar" } },
+					"required": ["kind"],
+					"type": "object"
+				},
+				"then": {
+					"required": ["part", "whole"],
+					"properties": {
+						"part": {
+							"description": "The shaded part.",
+							"type": "number",
+							"minimum": 0
+						},
+						"whole": {
+							"description": "The whole strip, 100 %.",
+							"type": "number",
+							"exclusiveMinimum": 0
+						}
+					},
+					"type": "object"
+				}
+			}],
+			"unevaluatedProperties": false
+		},
+		"figure": {
+			"description": "A figure: drawn from data (draw) or a bundled image (image, with its source and licence), one of the two. It has an alternative text that says what it shows, and a caption that says what to see.",
+			"required": ["alt", "caption"],
+			"allOf": [{ "$ref": "#/$defs/credit" }],
+			"properties": {
+				"draw": { "$ref": "#/$defs/drawing" },
+				"image": { "$ref": "#/$defs/image" },
+				"alt": {
+					"description": "What the figure shows, for those who cannot see it.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+				},
+				"caption": {
+					"description": "What to see in the figure, under it.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/markdown"
+				}
+			},
+			"dependentRequired": { "image": ["source", "licence"] },
+			"type": "object"
+		},
+		"labelledFigure": {
+			"description": "A bundled image with labels at positions. Each label shows its marker (A, B, 1a; else its number in order). The texts of the labels are listed beside the image (the legend), unless legend is false.",
+			"required": [
+				"image",
+				"alt",
+				"labels",
+				"source",
+				"licence"
+			],
+			"allOf": [{ "$ref": "#/$defs/credit" }],
+			"properties": {
+				"image": { "$ref": "#/$defs/image" },
+				"alt": {
+					"description": "What the image shows, for those who cannot see it.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+				},
+				"caption": {
+					"description": "What to see in the figure.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/markdown"
+				},
+				"legend": {
+					"description": "Whether the texts of the labels are listed beside the image. Default true. With false the figure shows only the markers (for a figure the learner labels), and alt names every marker with its part.",
+					"type": "boolean"
+				},
+				"labels": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"type": "object",
+						"additionalProperties": false,
+						"required": [
+							"x",
+							"y",
+							"text"
+						],
+						"properties": {
+							"marker": {
+								"description": "What the label shows on the image, plain text of 1 to 3 characters (A, B, 1a), the letters of the material. Each marker is used once. Without it: the number of the label in order, from 1.",
+								"type": "string",
+								"minLength": 1,
+								"maxLength": 3
+							},
+							"x": {
+								"description": "From the left edge, in percent of the width.",
+								"type": "number",
+								"minimum": 0,
+								"maximum": 100
+							},
+							"y": {
+								"description": "From the top edge, in percent of the height.",
+								"type": "number",
+								"minimum": 0,
+								"maximum": 100
+							},
+							"text": {
+								"description": "What the label names.",
+								"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+							}
+						}
+					}
+				}
+			},
+			"type": "object"
+		},
+		"materialBlock": {
+			"description": "A block that shows content with a question: a figure or a labelled figure.",
+			"type": "object",
+			"required": ["type"],
+			"properties": { "type": {
+				"description": "The kind of block.",
+				"enum": [
+					"text",
+					"formula",
+					"figure",
+					"labelled-figure",
+					"table",
+					"quote",
+					"code"
+				]
+			} },
+			"allOf": [
+				{
+					"if": {
+						"properties": { "type": { "const": "text" } },
+						"required": ["type"],
+						"type": "object"
+					},
+					"then": { "$ref": "#/$defs/textBlock" }
+				},
+				{
+					"if": {
+						"properties": { "type": { "const": "formula" } },
+						"required": ["type"],
+						"type": "object"
+					},
+					"then": { "$ref": "#/$defs/formula" }
+				},
+				{
+					"if": {
+						"properties": { "type": { "const": "figure" } },
+						"required": ["type"],
+						"type": "object"
+					},
+					"then": { "$ref": "#/$defs/figure" }
+				},
+				{
+					"if": {
+						"properties": { "type": { "const": "labelled-figure" } },
+						"required": ["type"],
+						"type": "object"
+					},
+					"then": { "$ref": "#/$defs/labelledFigure" }
+				},
+				{
+					"if": {
+						"properties": { "type": { "const": "table" } },
+						"required": ["type"],
+						"type": "object"
+					},
+					"then": { "$ref": "#/$defs/table" }
+				},
+				{
+					"if": {
+						"properties": { "type": { "const": "quote" } },
+						"required": ["type"],
+						"type": "object"
+					},
+					"then": { "$ref": "#/$defs/quote" }
+				},
+				{
+					"if": {
+						"properties": { "type": { "const": "code" } },
+						"required": ["type"],
+						"type": "object"
+					},
+					"then": { "$ref": "#/$defs/code" }
+				}
+			],
+			"unevaluatedProperties": false
+		},
+		"textBlock": {
+			"description": "Prose in restricted Markdown.",
+			"required": ["text"],
+			"properties": { "text": { "$ref": "urn:lernapps:schema:text.v1#/$defs/markdown" } },
+			"type": "object"
+		},
+		"formula": {
+			"description": "One formula on its own line, rendered at build to MathML.",
+			"required": ["formula"],
+			"properties": { "formula": { "$ref": "#/$defs/latex" } },
+			"type": "object"
+		},
+		"latex": {
+			"description": "One formula in the LaTeX subset of the formula command list: \\frac, \\cdot, \\times, \\div, \\%, \\text, ^, _, \\sqrt, \\approx, \\pm, \\le, \\ge, \\neq, \\, (thin space), parentheses and braces; \\ce{…} for chemical equations and \\pu{…} for units (mhchem). Written without the $ signs. A map by language only when it has \\text{…} that differs by language.",
+			"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+		},
+		"table": {
+			"description": "A table with a caption. Cells are restricted Markdown without paragraphs.",
+			"required": ["caption", "rows"],
+			"properties": {
+				"caption": {
+					"description": "What the table shows.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+				},
+				"header": {
+					"description": "The header row: one heading per column.",
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "urn:lernapps:schema:text.v1#/$defs/markdown" }
+				},
+				"rowHeaders": {
+					"description": "The first cell of each row heads the row.",
+					"type": "boolean",
+					"default": false
+				},
+				"rows": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"type": "array",
+						"minItems": 1,
+						"items": { "$ref": "urn:lernapps:schema:text.v1#/$defs/markdown" }
+					}
+				}
+			},
+			"type": "object"
+		},
+		"quote": {
+			"description": "A quotation, quoted exactly, with its origin, source and licence.",
+			"required": [
+				"text",
+				"origin",
+				"source",
+				"licence"
+			],
+			"allOf": [{ "$ref": "#/$defs/credit" }],
+			"properties": {
+				"text": {
+					"description": "The quotation itself, exactly as written.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/markdown"
+				},
+				"origin": {
+					"description": "Who said or wrote it, where and when.",
+					"type": "object",
+					"additionalProperties": false,
+					"required": ["author"],
+					"properties": {
+						"author": {
+							"description": "Who said or wrote it. A name is the same in every language: a string, or a map by language where it differs.",
+							"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+						},
+						"work": {
+							"description": "Where it was said or written: the work, as it is called; a string, or a map by language where its title is translated.",
+							"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+						},
+						"year": {
+							"anyOf": [{ "type": "integer" }, { "$ref": "urn:lernapps:schema:text.v1#/$defs/text" }],
+							"description": "When: a year, or a text such as um 500 v. Chr."
+						}
+					}
+				}
+			},
+			"type": "object"
+		},
+		"code": {
+			"description": "Program code, highlighted at build.",
+			"required": ["language", "code"],
+			"properties": {
+				"language": { "enum": [
+					"bash",
+					"c",
+					"css",
+					"html",
+					"java",
+					"javascript",
+					"json",
+					"plaintext",
+					"python",
+					"sql",
+					"typescript"
+				] },
+				"code": {
+					"description": "The code, as it is.",
+					"type": "string",
+					"minLength": 1
+				},
+				"caption": {
+					"description": "What the code does.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+				}
+			},
+			"type": "object"
+		}
+	}
+};
+// runtime/shared/text/text.v1.schema.json
+var text_v1_schema_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "urn:lernapps:schema:text.v1",
+	title: "A learner text",
+	description: "The texts of the content of an app: a text, and restricted Markdown, each a string while German is the only language of the app, else a map of texts by language. The schemas of the quiz, of the explainer and of the blocks they share refer to it.",
+	$defs: {
+		"text": {
+			"description": "A text for learners without formatting: a string while German is the only language of the app, else a map of texts by language ({ de: …, en: … }) with every declared language.",
+			"anyOf": [{
+				"type": "string",
+				"minLength": 1,
+				"pattern": "\\S"
+			}, {
+				"type": "object",
+				"minProperties": 1,
+				"propertyNames": { "pattern": "^[a-z]{2}$" },
+				"additionalProperties": {
+					"type": "string",
+					"minLength": 1,
+					"pattern": "\\S"
+				}
+			}]
+		},
+		"markdown": {
+			"description": "Restricted Markdown, as a text or a map of texts by language: paragraphs, **bold**, *italics*, lists, links and line breaks, formulas as $…$ in the formula command list. No headings (use a section block), no HTML, no images (use a figure block), no code (use a code block), no quotes (use a quote block), no tables (use a table block). A link to a page of the app starts with / and names it from the app's root: /<chapter>/<page>/#<section>.",
+			"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+		}
+	}
+};
+// runtime/shared/questions/question.v1.schema.json
+var question_v1_schema_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "urn:lernapps:schema:question.v1",
+	title: "A question of a lernapps app",
+	description: "One question of the six types (single-choice, multiple-choice, true-false, number, ordering, matching) as the quiz's question bank and the explainer's exercises write it. Use #/$defs/question for one question; the schemas of the quiz and of the explainer refer to it.",
+	$defs: {
+		"question": {
+			"type": "object",
+			"required": [
+				"id",
+				"type",
+				"text",
+				"explanation",
+				"links"
+			],
+			"properties": {
+				"id": {
+					"description": "Stable name of the question, used in its address (#frage-<id>): lower-case letters, digits and hyphens. Keep it when the text changes, so links to the question keep working.",
+					"type": "string",
+					"pattern": "^[a-z0-9]+(-[a-z0-9]+)*$"
+				},
+				"type": {
+					"description": "The kind of question.",
+					"enum": [
+						"single-choice",
+						"multiple-choice",
+						"true-false",
+						"number",
+						"ordering",
+						"matching"
+					]
+				},
+				"text": {
+					"description": "The question, complete in itself.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+				},
+				"material": {
+					"description": "Optional: content that the question shows, between its text and its answers: prose, formulas, figures and labelled figures (bundled images in src/images/, or drawn from data), tables, quotations and code. A figure has an alternative text and a caption, and an image its source and licence. A question that asks about what the content shows needs it; one that merely looks nicer with an image should not have one.",
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "urn:lernapps:schema:blocks.v1#/$defs/materialBlock" }
+				},
+				"explanation": {
+					"description": "Why the right answer is right, in one to three sentences. For number, ordering and matching questions also the background knowledge, as their options carry none.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+				},
+				"links": {
+					"description": "Further reading on the question, at least one link, e.g. to the article in the German Wikipedia; in a quiz or on a page in several languages to the article in each language's Wikipedia, with url as a map by language.",
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/link" }
+				},
+				"hint": {
+					"description": "Optional: what to look at again after a wrong answer, in one sentence, without giving the answer away, e.g. \"Schau dir noch einmal an, wie hoch die Spannung im Haushalt ist.\" Shown with the feedback of a wrong answer when nothing more specific applies: a chosen option's info or a number's typical mistake come first. In an explainer, a wrong answer can be tried again, with this hint, before the solution shows.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+				},
+				"examples": { "$ref": "#/$defs/examples" }
+			},
+			"allOf": [
+				{
+					"if": {
+						"type": "object",
+						"properties": { "type": { "const": "single-choice" } },
+						"required": ["type"]
+					},
+					"then": { "$ref": "#/$defs/choice" }
+				},
+				{
+					"if": {
+						"type": "object",
+						"properties": { "type": { "const": "multiple-choice" } },
+						"required": ["type"]
+					},
+					"then": { "$ref": "#/$defs/choice" }
+				},
+				{
+					"if": {
+						"type": "object",
+						"properties": { "type": { "const": "true-false" } },
+						"required": ["type"]
+					},
+					"then": { "$ref": "#/$defs/trueFalse" }
+				},
+				{
+					"if": {
+						"type": "object",
+						"properties": { "type": { "const": "number" } },
+						"required": ["type"]
+					},
+					"then": { "$ref": "#/$defs/number" }
+				},
+				{
+					"if": {
+						"type": "object",
+						"properties": { "type": { "const": "ordering" } },
+						"required": ["type"]
+					},
+					"then": { "$ref": "#/$defs/ordering" }
+				},
+				{
+					"if": {
+						"type": "object",
+						"properties": { "type": { "const": "matching" } },
+						"required": ["type"]
+					},
+					"then": { "$ref": "#/$defs/matching" }
+				}
+			],
+			"unevaluatedProperties": false
+		},
+		"examples": {
+			"description": "Optional: test cases for the build, never shown to learners. Before you write the question, note which answers fulfil its text and which typical wrong answers there are; write the other correct answers the text allows (also those other than the one you marked) into accepted, the typical wrong ones into rejected. The build runs each through the same check the page uses and fails when it accepts a rejected answer or rejects an accepted one: then the question checks something other than what its text asks (e.g. an ordering whose text says the order does not matter), so change the question or its text. An answer as the learner gives it, by the type: single-choice an option; multiple-choice a list of options, e.g. [0, 2]; true-false true or false; number a number, or the text as a learner types it, e.g. \"12,5\"; ordering every item in the learner's order; matching a list of pairs [left, right], one for each left entry. An option, item or entry is its index from 0 in the order written, or its text as written (in German). A number's mistakes and the info of wrong options already count as rejected.",
+			"type": "object",
+			"additionalProperties": false,
+			"minProperties": 1,
+			"properties": {
+				"accepted": {
+					"description": "Answers the text allows, each of which the check must accept.",
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/exampleAnswer" }
+				},
+				"rejected": {
+					"description": "Typical wrong answers, each of which the check must reject.",
+					"type": "array",
+					"minItems": 1,
+					"items": { "$ref": "#/$defs/exampleAnswer" }
+				}
+			}
+		},
+		"exampleAnswer": { "description": "An answer as the learner gives it, in the shape of the question's type (see examples); the build checks its shape." },
+		"choice": {
+			"type": "object",
+			"description": "Single choice: exactly one option is correct. Multiple choice: at least one option is correct, and the learner selects every correct one.",
+			"required": ["options"],
+			"properties": { "options": {
+				"type": "array",
+				"minItems": 2,
+				"maxItems": 8,
+				"items": {
+					"type": "object",
+					"additionalProperties": false,
+					"required": [
+						"text",
+						"correct",
+						"info"
+					],
+					"properties": {
+						"text": {
+							"description": "The option as the learner reads it.",
+							"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+						},
+						"correct": {
+							"description": "Whether this option is correct.",
+							"type": "boolean"
+						},
+						"info": {
+							"description": "One to three sentences of background on this option itself, true whether or not it is the right answer, e.g. \"Der Uluru ist ein Inselberg in der Wüste Zentralaustraliens ...\". After an answer it shows for every option. For a wrong option it is also the reason a learner who chose it reads with the feedback, so say there why it does not fit.",
+							"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+						},
+						"alt": {
+							"description": "Optional: the option as it is spoken, for the name of its radio button or checkbox, when its text is only a formula, e.g. \"zwei hoch sieben\" for \"$2^7$\". Without it the name is made from the formula in the page's language (\"2 hoch 7\"); write it where that reads badly, e.g. for a chemical formula. Not needed when the text has words.",
+							"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+						},
+						"link": {
+							"description": "Further reading on this option.",
+							"$ref": "#/$defs/link"
+						}
+					}
+				}
+			} }
+		},
+		"trueFalse": {
+			"type": "object",
+			"description": "A statement the learner judges as true or false; the background goes into the explanation.",
+			"required": ["answer"],
+			"properties": { "answer": {
+				"description": "Whether the statement is true.",
+				"type": "boolean"
+			} }
+		},
+		"number": {
+			"type": "object",
+			"description": "The learner types a number; it counts when it is within the tolerance of the answer. A comma or a point both work as the decimal sign. The background goes into the explanation.",
+			"required": ["answer", "tolerance"],
+			"properties": {
+				"answer": {
+					"description": "The right number.",
+					"type": "number"
+				},
+				"tolerance": {
+					"description": "How far the learner's number may be from the answer and still count; 0 for an exact answer. Match it to the rounding the question asks for.",
+					"type": "number",
+					"minimum": 0
+				},
+				"unit": {
+					"description": "The unit, shown next to the input, e.g. \"cm\"; the learner does not type it.",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+				},
+				"mistakes": {
+					"description": "Optional: typical wrong numbers, each with a message that says what went wrong, e.g. { \"answer\": 2300, \"message\": \"Du hast mit 10 statt mit 100 multipliziert.\" }. A learner's number within the tolerance of a mistake's answer gets its message with the feedback. A mistake's answer must not count as right, and each is listed once.",
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"type": "object",
+						"additionalProperties": false,
+						"required": ["answer", "message"],
+						"properties": {
+							"answer": {
+								"description": "The wrong number, as the mistake gives it.",
+								"type": "number"
+							},
+							"message": {
+								"description": "What went wrong, in one or two sentences, without giving the right number away.",
+								"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+							}
+						}
+					}
+				}
+			}
+		},
+		"ordering": {
+			"type": "object",
+			"description": "The learner puts the items in order, e.g. by height. Write them in the right order: the page shows them mixed. The background goes into the explanation.",
+			"required": ["items"],
+			"properties": { "items": {
+				"type": "array",
+				"minItems": 2,
+				"maxItems": 8,
+				"items": { "$ref": "urn:lernapps:schema:text.v1#/$defs/text" }
+			} }
+		},
+		"matching": {
+			"type": "object",
+			"description": "The learner matches each left entry with its right entry. Write the pairs as they belong together: the page shows the right entries mixed. The background goes into the explanation. Instead of the pairs, a question about a figure to label takes them from the figure (pairsFrom).",
+			"properties": {
+				"pairsFrom": {
+					"description": "material: the pairs are the labels of the labelled figure in the material, each marker (A, B, 1) on the left with its text on the right, so that they are written once. The figure must have legend: false, as its legend would give the answers away; the solution lists them. Write either the pairs or pairsFrom.",
+					"const": "material"
+				},
+				"distractors": {
+					"description": "Optional: right entries that match none of the left entries, wrong answers the learner may choose, shown mixed with the right entries. Use them for plausible mistakes, or for entries that have nothing to do with the task; 1 to 4 of them.",
+					"type": "array",
+					"minItems": 1,
+					"maxItems": 4,
+					"items": { "$ref": "urn:lernapps:schema:text.v1#/$defs/text" }
+				},
+				"pairs": {
+					"description": "The pairs, written out. Without pairsFrom they are required.",
+					"type": "array",
+					"minItems": 2,
+					"maxItems": 8,
+					"items": {
+						"type": "object",
+						"additionalProperties": false,
+						"required": ["left", "right"],
+						"properties": {
+							"left": { "$ref": "urn:lernapps:schema:text.v1#/$defs/text" },
+							"right": { "$ref": "urn:lernapps:schema:text.v1#/$defs/text" }
+						}
+					}
+				}
+			}
+		},
+		"link": {
+			"type": "object",
+			"additionalProperties": false,
+			"required": ["title", "url"],
+			"properties": {
+				"title": {
+					"description": "The link's text: what the learner finds there, e.g. \"Uluru (Wikipedia)\".",
+					"$ref": "urn:lernapps:schema:text.v1#/$defs/text"
+				},
+				"url": {
+					"description": "The address, https only: one for every language, or, in a quiz or on a page in several languages where the page to read differs by language (the article in each language's Wikipedia), a map of addresses by language ({ \"de\": \"https://de.wikipedia.org/wiki/Uluru\", \"en\": \"https://en.wikipedia.org/wiki/Uluru\" }) with every declared language, as a text's map. Each language's page links the address of its language. Check that each opens the page you mean.",
+					"$ref": "#/$defs/address"
+				}
+			}
+		},
+		"address": {
+			"description": "An address, https only: a string, the same in every language, or a map of addresses by language ({ de: …, en: … }) in a quiz or on a page in several languages. The quiz or page checks that a map has every language it declares, and no other.",
+			"anyOf": [{
+				"type": "string",
+				"pattern": "^https://[^\\s]+$"
+			}, {
+				"type": "object",
+				"minProperties": 1,
+				"propertyNames": { "pattern": "^[a-z]{2}$" },
+				"additionalProperties": {
+					"type": "string",
+					"pattern": "^https://[^\\s]+$"
+				}
+			}]
+		}
+	}
+};
+// runtime/shared/questions/validate.ts
+/** The id of the schema of a question, to refer to it from another schema (with `questionSchemas` added to its validator). */
+const QUESTION_SCHEMA_ID = question_v1_schema_default.$id;
+/** The reference to one question in the schema of a question, for a `$ref` from another schema. */
+const QUESTION_REF = `${QUESTION_SCHEMA_ID}#/$defs/question`;
+/** The schema of a question (question.v1.schema.json), to add to another schema's validator. */
+const questionSchema = question_v1_schema_default;
+/** The schemas a question refers to, and its own: every validator of a schema that refers to a question adds them. */
+const questionSchemas = [
+	text_v1_schema_default,
+	blocks_v1_schema_default,
+	question_v1_schema_default
+];
+const schemas = schemasById(...questionSchemas);
+/** The definition of the fields of each type of question in its schema. */
+const QUESTION_BRANCH = {
+	"single-choice": "choice",
+	"multiple-choice": "choice",
+	"true-false": "trueFalse",
+	number: "number",
+	ordering: "ordering",
+	matching: "matching"
+};
+const ajv = new Ajv2020({
+	allErrors: true,
+	strict: true
+});
+for (const each of questionSchemas) ajv.addSchema(each);
+const validateOne = (() => {
+	const validate = ajv.getSchema(QUESTION_REF);
+	if (validate === void 0) throw new Error(`the question's schema has no ${QUESTION_REF}`);
+	return validate;
+})();
+/** `["options", "1", "text"]` as `.options[1].text`. */
+const readable = (parts) => parts.map((part) => /^\d+$/.test(part) ? `[${part}]` : `.${part}`).join("");
+/** Where something in a question is: the question at `at`, the path below it, and the question's id if it has one. */
+function inQuestion(at, parts, question) {
+	const id = typeof question === "object" && question !== null && "id" in question && typeof question.id === "string" ? question.id : void 0;
+	return id === void 0 ? `${at}${readable(parts)}` : `${at}${readable(parts)} (question "${id}")`;
+}
+/** `/questions/2/options/1/text` as `questions[2].options[1].text`, with the id of the question. */
+function valueAt(root, pointer) {
+	return pointer.split("/").slice(1).reduce((at, part) => typeof at === "object" && at !== null ? at[part] : void 0, root);
+}
+/** A learner text that is neither a text nor a map of texts. */
+function textMessage(value, at) {
+	if (typeof value === "string") return `${at}: must not be empty`;
+	if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+		const bad = Object.entries(value).find(([lang, text]) => !/^[a-z]{2}$/.test(lang) || typeof text !== "string" || text.trim() === "");
+		if (bad !== void 0) return /^[a-z]{2}$/.test(bad[0]) ? `${at} (${bad[0]}): must not be empty` : `${at}: ${bad[0]} is not a language code; use two letters, e.g. de, en`;
+	}
+	return `${at}: must be a text, or a map of texts by language: { de: …, en: … }`;
+}
+/**
+* What is wrong with a link's address that is neither an https address nor a map of them by language: in which
+* language, when it is one of a map. Also for the explainer, which embeds the quiz's question types.
+*/
+function addressProblem(value) {
+	if (typeof value === "object" && value !== null && !Array.isArray(value)) for (const [lang, address] of Object.entries(value)) {
+		if (!/^[a-z]{2}$/.test(lang)) return { message: `${lang} is not a language code; use two letters, e.g. de, en` };
+		if (typeof address !== "string" || !/^https:\/\/\S+$/.test(address)) return {
+			lang,
+			message: "must be an https address"
+		};
+	}
+	return { message: "must be an https address, or a map of https addresses by language: { de: https://…, en: https://… }" };
+}
+function schemaMessage(error, at) {
+	switch (error.keyword) {
+		case "if": return;
+		case "required": return `${at}: ${String(error.params["missingProperty"])} is missing`;
+		case "additionalProperties": return `${at}: ${String(error.params["additionalProperty"])} is not allowed here`;
+		case "unevaluatedProperties": return `${at}: ${String(error.params["unevaluatedProperty"])} is not allowed ${/\/material\/\d+$/.test(error.instancePath) ? "in this type of block" : "for this type of question"}`;
+		case "enum": return `${at}: must be one of ${error.params["allowedValues"].join(", ")}`;
+		case "pattern": return error.instancePath.endsWith("/id") ? `${at}: use lower-case letters, digits and hyphens, e.g. "brueche-kuerzen"` : `${at}: must not be empty`;
+		default: return `${at}: ${error.message ?? "is invalid"}`;
+	}
+}
+/** The messages of the schema's errors, each at the place `where` names for its path. */
+function schemaMessages(errors, where, root) {
+	const texts = new Set(errors.filter((error) => error.keyword === "anyOf").map((error) => error.instancePath));
+	const underText = (path) => [...texts].some((text) => path === text || path.startsWith(`${text}/`));
+	const unknownType = new Set(errors.filter((error) => error.keyword === "enum" && error.instancePath.endsWith("/type")).map((error) => error.instancePath.slice(0, -5)));
+	const isKnown = (error) => {
+		if (error.keyword !== "unevaluatedProperties") return false;
+		const value = valueAt(root, error.instancePath);
+		const type = typeof value === "object" && value !== null && "type" in value ? String(value.type) : "";
+		const property = String(error.params["unevaluatedProperty"]);
+		const material = /\/material\/\d+$/.test(error.instancePath) ? MATERIAL_DEFINITIONS[type] : void 0;
+		if (material !== void 0) return knownProperties(schemas, blocks_v1_schema_default.$id, material).has(property);
+		const branch = QUESTION_BRANCH[type];
+		return branch !== void 0 && (knownProperties(schemas, question_v1_schema_default.$id, "question", { branches: false }).has(property) || knownProperties(schemas, question_v1_schema_default.$id, branch).has(property));
+	};
+	return errors.filter((error) => !(error.keyword === "unevaluatedProperties" && (unknownType.has(error.instancePath) || isKnown(error)))).filter((error) => error.keyword === "anyOf" || !underText(error.instancePath)).flatMap((error) => {
+		if (error.keyword !== "anyOf") return schemaMessage(error, where(error.instancePath)) ?? [];
+		const value = valueAt(root, error.instancePath);
+		if (!error.instancePath.endsWith("/url")) return textMessage(value, where(error.instancePath));
+		const { lang, message } = addressProblem(value);
+		return `${where(error.instancePath)}${lang === void 0 ? "" : ` (${lang})`}: ${message}`;
+	});
+}
+function duplicates(values) {
+	return [...new Set(values.filter((value, index) => values.indexOf(value) !== index))];
+}
+/** Where the pairs of a matching question come from: written, or taken from the labelled figure of its material. */
+function pairsSourceProblems(question) {
+	const written = question.pairs !== void 0;
+	if (question.pairsFrom === void 0) return written ? [] : [{
+		path: ["pairs"],
+		message: "pairs is missing; write the pairs, or take them from the labelled figure of the material with pairsFrom: material"
+	}];
+	if (written) return [{
+		path: ["pairsFrom"],
+		message: "pairs and pairsFrom: write the pairs, or take them from the material, not both"
+	}];
+	const index = question.material?.findIndex((block) => block.type === "labelled-figure") ?? -1;
+	const figure = question.material?.[index];
+	if (figure?.type !== "labelled-figure") return [{
+		path: ["pairsFrom"],
+		message: "the material has no labelled figure; add one, or write the pairs"
+	}];
+	const problems = [];
+	if (figure.legend !== false) problems.push({
+		path: [
+			"material",
+			index,
+			"legend"
+		],
+		message: "the legend of the figure lists the answers before the question is answered; write legend: false, the solution shows them"
+	});
+	if (figure.labels.length < 2 || figure.labels.length > 8) problems.push({
+		path: ["pairsFrom"],
+		message: `the figure has ${figure.labels.length} labels; a matching question takes 2 to 8 pairs`
+	});
+	return problems;
+}
+/** What the schema cannot say about one question, its texts in German. */
+function questionProblems(question) {
+	const problems = [];
+	const twice = (what, path, values) => {
+		for (const value of duplicates(values)) problems.push({
+			path: [path],
+			message: `the ${what} "${value}" appears twice`
+		});
+	};
+	switch (question.type) {
+		case "single-choice": {
+			const correct = question.options.filter((option) => option.correct).length;
+			if (correct !== 1) problems.push({
+				path: ["options"],
+				message: `a single-choice question needs exactly one correct option; it has ${correct}. Mark one option "correct": true, or make it "multiple-choice"`
+			});
+			twice("option", "options", question.options.map((option) => option.text));
+			break;
+		}
+		case "multiple-choice":
+			if (!question.options.some((option) => option.correct)) problems.push({
+				path: ["options"],
+				message: "a multiple-choice question needs at least one correct option; it has none"
+			});
+			twice("option", "options", question.options.map((option) => option.text));
+			break;
+		case "ordering":
+			twice("item", "items", question.items);
+			break;
+		case "matching":
+			twice("left entry", "pairs", question.pairs.map((pair) => pair.left));
+			twice("right entry", "pairs", rightEntries(question));
+			break;
+		case "number":
+			question.mistakes?.forEach((mistake, index) => {
+				if (Math.abs(mistake.answer - question.answer) <= question.tolerance + 1e-9) problems.push({
+					path: [
+						"mistakes",
+						index,
+						"answer"
+					],
+					message: `the mistake ${mistake.answer} counts as right: it is within the tolerance of the answer ${question.answer}; give the wrong number the mistake leads to`
+				});
+			});
+			for (const value of duplicates((question.mistakes ?? []).map((mistake) => String(mistake.answer)))) problems.push({
+				path: ["mistakes"],
+				message: `the mistake ${value} appears twice; list each wrong number once`
+			});
+	}
+	return problems;
+}
+/** The index of an option, item or entry given as its index from 0 or as its text in German; or what is wrong. */
+function indexOf(value, texts, what) {
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value < texts.length) return value;
+	if (typeof value === "string" && texts.includes(value)) return texts.indexOf(value);
+	return `${typeof value === "string" ? `"${value}"` : JSON.stringify(value)} is not ${what}; give its index from 0 to ${texts.length - 1}, or its text as written (in German)`;
+}
+/** Indices of `values`, each in `texts`; or the first problem. */
+function indicesOf(values, texts, what) {
+	const found = values.map((value) => indexOf(value, texts, what));
+	const problem = found.find((value) => typeof value === "string");
+	return typeof problem === "string" ? problem : found;
+}
+/**
+* An example as the checker receives a learner's answer to `question` (in German): single choice an option, multiple
+* choice a list of options, true/false a boolean, number a number or the text a learner types, ordering the items in
+* the learner's order, matching a list of pairs [left, right]; an option, item or entry by its index from 0 or its
+* text. A complete answer, as the page only checks one.
+*/
+function exampleAnswer(question, example) {
+	const expect = (what) => ({ problem: `give ${what}` });
+	let answer;
+	switch (question.type) {
+		case "single-choice": {
+			const index = indexOf(example, question.options.map((option) => option.text), "an option");
+			if (typeof index === "string") return { problem: index };
+			answer = index;
+			break;
+		}
+		case "multiple-choice": {
+			if (!Array.isArray(example)) return expect("the chosen options as a list: [0, 2]");
+			const indices = indicesOf(example, question.options.map((option) => option.text), "an option");
+			if (typeof indices === "string") return { problem: indices };
+			answer = [...new Set(indices)].sort((a, b) => a - b);
+			break;
+		}
+		case "true-false":
+			if (typeof example !== "boolean") return expect("true or false");
+			answer = example;
+			break;
+		case "number":
+			if (typeof example === "number") answer = String(example);
+			else if (typeof example === "string" && parseNumber(example, question.unit) !== void 0) answer = example;
+			else return expect("a number, or the text a learner types, e.g. \"12,5\"");
+			break;
+		case "ordering": {
+			if (!Array.isArray(example)) return expect("the items in the learner's order as a list");
+			const order = indicesOf(example, question.items, "an item");
+			if (typeof order === "string") return { problem: order };
+			if (new Set(order).size !== question.items.length || order.length !== question.items.length) return expect(`each of the ${question.items.length} items once, in the learner's order`);
+			answer = question.items.map((_item, index) => order.indexOf(index));
+			break;
+		}
+		case "matching": {
+			const pairs = Array.isArray(example) ? example : [];
+			if (!Array.isArray(example) || pairs.some((pair) => !Array.isArray(pair) || pair.length !== 2)) return expect("a list of pairs [left, right]");
+			const lefts = indicesOf(pairs.map((pair) => pair[0]), question.pairs.map((pair) => pair.left), "a left entry");
+			if (typeof lefts === "string") return { problem: lefts };
+			const rights = indicesOf(pairs.map((pair) => pair[1]), rightEntries(question), "a right entry");
+			if (typeof rights === "string") return { problem: rights };
+			if (new Set(lefts).size !== question.pairs.length || lefts.length !== question.pairs.length) return expect(`one pair for each of the ${question.pairs.length} left entries`);
+			answer = question.pairs.map((_pair, index) => rights[lefts.indexOf(index)] ?? -1);
+			break;
+		}
+	}
+	return isComplete(question, answer) ? { answer } : expect("a complete answer: the page checks only those");
+}
+/**
+* Whether each example of `question` (in German) gets the verdict it is listed with from the same check the page
+* uses: an accepted one passes, a rejected one fails. Each problem at the example's place.
+*/
+function exampleProblems(question, examples) {
+	const problems = [];
+	for (const kind of ["accepted", "rejected"]) (examples?.[kind] ?? []).forEach((example, index) => {
+		const path = [
+			"examples",
+			kind,
+			index
+		];
+		const given = exampleAnswer(question, example);
+		if ("problem" in given) {
+			problems.push({
+				path,
+				message: given.problem
+			});
+			return;
+		}
+		const right = isCorrect(question, given.answer);
+		if (right === (kind === "accepted")) return;
+		problems.push({
+			path,
+			message: verdict(JSON.stringify(example), right, "the check", "change the question (e.g. another type, a tolerance) so that its check")
+		});
+	});
+	return problems;
+}
+/**
+* The problems of a question that matches the schema, with their place in it: its texts complete in each of
+* `languages` and in no other (German first, with the messages of the explainer's language check), so its addresses
+* given as maps, then what the schema cannot say. A plain string is German, complete only while German is the only
+* language; a plain address is the same in every language.
+*/
+function questionDetails(question, languages = ["de"], declaredIn, app) {
+	const problems = [];
+	if (question.material !== void 0) {
+		const found = checkMaterial(question.material, {
+			languages,
+			...declaredIn === void 0 ? {} : { declaredIn },
+			imageExists: app?.imageExists ?? (() => false),
+			...app?.onLink === void 0 ? {} : { onLink: app.onLink }
+		});
+		for (const problem of found) problems.push({
+			...problem,
+			path: ["material", ...problem.path]
+		});
+	}
+	if (question.type === "matching") {
+		const source = pairsSourceProblems(question);
+		if (source.length > 0) return [...problems, ...source];
+	}
+	for (const { path, text } of questionTexts(question)) for (const problem of textLanguages(text, languages, false, declaredIn).problems) problems.push({
+		path,
+		lang: problem.lang,
+		message: problem.message
+	});
+	for (const { path, text } of questionAddresses(question)) for (const problem of textLanguages(text, languages, true, declaredIn).problems) problems.push({
+		path,
+		lang: problem.lang,
+		message: problem.message
+	});
+	const german = questionIn(question, "de");
+	const own = questionProblems(german).map((problem) => question.type === "matching" && question.pairsFrom !== void 0 && problem.path[0] === "pairs" ? {
+		...problem,
+		path: ["pairsFrom"]
+	} : problem);
+	return [
+		...problems,
+		...own,
+		...exampleProblems(german, question.examples)
+	];
+}
+/** Whether `value` matches the schema of one question; its errors as messages at `at` otherwise. */
+function questionSchemaProblems(value, at) {
+	if (validateOne(value)) return [];
+	return schemaMessages(validateOne.errors ?? [], (path) => inQuestion(at, path.split("/").slice(1), value), value);
+}
+/**
+* The problems of one question; none when it is valid. `at` is where the question is, e.g. `questions[2]` in a bank
+* or `blocks[3]` on a page; each problem starts with it, the path below it and the question's id. `languages` are the
+* declared languages of the page, declared in `declaredIn` (src/app.yaml by default).
+*/
+function validateQuestion(value, at, languages = ["de"], declaredIn, app) {
+	const schemaProblems = questionSchemaProblems(value, at);
+	if (schemaProblems.length > 0) return schemaProblems;
+	const question = value;
+	return questionDetails(question, languages, declaredIn, app).map((problem) => {
+		const path = problem.path.at(-1) === problem.lang ? problem.path.slice(0, -1) : problem.path;
+		return problem.lang === void 0 && problem.path[0] !== "examples" && problem.path[0] !== "material" ? `${at} (question "${question.id}"): ${problem.message}` : `${at}${readable(path.map(String))}${problem.lang === void 0 ? "" : ` (${problem.lang})`} (question "${question.id}"): ${problem.message}`;
+	});
+}
+export { verdict as _, duplicates as a, questionSchema as c, readable as d, schemaMessages as f, schemasById as g, knownProperties as h, addressProblem as i, questionSchemaProblems as l, question_v1_schema_default as m, QUESTION_REF as n, inQuestion as o, validateQuestion as p, QUESTION_SCHEMA_ID as r, questionDetails as s, QUESTION_BRANCH as t, questionSchemas as u };