@lernapps/app-templates 0.0.1 → 0.1.1

package/dist/block-BK_ohsH1.mjs

@@ -0,0 +1,82 @@
+import { i as inLanguage } from "./html-mffkHGHh.mjs";
+// runtime/shared/blocks/block.ts
+/** The marker of the label at `index`: the one it names, else its number. */
+const markerOf = (label, index) => label.marker ?? String(index + 1);
+/** The types of the blocks that show content. */
+const MATERIAL_TYPES = [
+	"text",
+	"formula",
+	"figure",
+	"labelled-figure",
+	"table",
+	"quote",
+	"code"
+];
+/** The blocks with each text in `lang`. */
+function materialIn(blocks, lang) {
+	const t = (text) => inLanguage(text, lang);
+	const credit = (block) => ({
+		...block.source === void 0 ? {} : { source: t(block.source) },
+		...block.licence === void 0 ? {} : { licence: block.licence }
+	});
+	return blocks.map((block) => {
+		switch (block.type) {
+			case "text": return {
+				type: "text",
+				text: t(block.text)
+			};
+			case "formula": return {
+				type: "formula",
+				formula: t(block.formula)
+			};
+			case "figure": return {
+				type: "figure",
+				...block.draw === void 0 ? {} : { draw: block.draw },
+				...block.image === void 0 ? {} : { image: block.image },
+				alt: t(block.alt),
+				caption: t(block.caption),
+				...credit(block)
+			};
+			case "labelled-figure": return {
+				type: "labelled-figure",
+				image: block.image,
+				alt: t(block.alt),
+				...block.caption === void 0 ? {} : { caption: t(block.caption) },
+				...block.legend === void 0 ? {} : { legend: block.legend },
+				labels: block.labels.map((label) => ({
+					...label.marker === void 0 ? {} : { marker: label.marker },
+					x: label.x,
+					y: label.y,
+					text: t(label.text)
+				})),
+				...credit(block)
+			};
+			case "table": return {
+				type: "table",
+				caption: t(block.caption),
+				...block.header === void 0 ? {} : { header: block.header.map(t) },
+				...block.rowHeaders === void 0 ? {} : { rowHeaders: block.rowHeaders },
+				rows: block.rows.map((row) => row.map(t))
+			};
+			case "quote": return {
+				type: "quote",
+				text: t(block.text),
+				origin: {
+					author: t(block.origin.author),
+					...block.origin.work === void 0 ? {} : { work: t(block.origin.work) },
+					...block.origin.year === void 0 ? {} : { year: typeof block.origin.year === "number" ? block.origin.year : t(block.origin.year) }
+				},
+				...credit(block)
+			};
+			case "code": return {
+				type: "code",
+				language: block.language,
+				code: block.code,
+				...block.caption === void 0 ? {} : { caption: t(block.caption) }
+			};
+		}
+	});
+}
+/** The bundled images `blocks` use, each once, as paths from src/. */
+const materialImages = (blocks) => [...new Set(blocks.flatMap((block) => "image" in block && block.image !== void 0 ? [block.image] : []))];
+export { materialIn as i, markerOf as n, materialImages as r, MATERIAL_TYPES as t };

package/dist/blocks-CxtCPAa5.mjs

@@ -0,0 +1,149 @@
+import { i as inLanguage, l as textsIn, n as escapeText, s as localeOf, t as escape } from "./html-mffkHGHh.mjs";
+import { n as markerOf } from "./block-BK_ohsH1.mjs";
+import { c as renderMarkdown, n as isUrl, s as renderInline, u as renderFormula } from "./check-CteIFN96.mjs";
+import "./validate-Bxy9NfB8.mjs";
+import hljs from "highlight.js/lib/core";
+import bash from "highlight.js/lib/languages/bash";
+import c from "highlight.js/lib/languages/c";
+import css from "highlight.js/lib/languages/css";
+import java from "highlight.js/lib/languages/java";
+import javascript from "highlight.js/lib/languages/javascript";
+import json from "highlight.js/lib/languages/json";
+import python from "highlight.js/lib/languages/python";
+import sql from "highlight.js/lib/languages/sql";
+import typescript from "highlight.js/lib/languages/typescript";
+import xml from "highlight.js/lib/languages/xml";
+// runtime/shared/blocks/code.ts
+const languages = {
+	bash,
+	c,
+	css,
+	html: xml,
+	java,
+	javascript,
+	json,
+	python,
+	sql,
+	typescript
+};
+for (const [name, language] of Object.entries(languages)) hljs.registerLanguage(name, language);
+/** The code as highlighted HTML, for inside <code>. */
+function highlight(code, language) {
+	if (language === "plaintext") return escapeText(code);
+	return hljs.highlight(code, {
+		language,
+		ignoreIllegals: true
+	}).value;
+}
+// runtime/shared/blocks/figures.ts
+const ON = "#1d4ed8";
+const OFF = "#ffffff";
+const LINE = "#4a4a4a";
+/** A field of 10 × 10 squares, the first `filled` shaded, row by row. */
+function hundredGrid(filled, alt) {
+	const cells = [];
+	for (let index = 0; index < 100; index++) {
+		const x = 1 + index % 10 * 11;
+		const y = 1 + Math.floor(index / 10) * 11;
+		cells.push(`<rect x="${x}" y="${y}" width="10" height="10" class="${index < filled ? "fig-on" : "fig-off"} fig-line" fill="${index < filled ? ON : OFF}" stroke="${LINE}" stroke-width="0.5"/>`);
+	}
+	return `<svg class="block-drawing block-hundred-grid" role="img" aria-label="${escape(alt)}" viewBox="0 0 111 111" xmlns="http://www.w3.org/2000/svg">${cells.join("")}</svg>`;
+}
+/**
+* A strip for `whole`, `part` of it shaded; under it 0, part and whole, and their percentages (without them in a task
+* that asks for the percentage: `percent` false).
+*/
+function bar(part, whole, alt, locale, percent = true) {
+	const numbers = new Intl.NumberFormat(locale, { maximumFractionDigits: 2 });
+	const share = Math.min(part / whole, 1);
+	const width = 298 * share;
+	const at = Math.min(Math.max(1 + width, 50), 250);
+	const label = (x, y, anchor, text) => `<text x="${x.toFixed(1)}" y="${y}" text-anchor="${anchor}" font-size="12" class="fig-text" fill="#1a1a1a">${escape(text)}</text>`;
+	return [
+		`<svg class="block-drawing block-bar" role="img" aria-label="${escape(alt)}" viewBox="0 0 300 ${percent ? 74 : 58}" xmlns="http://www.w3.org/2000/svg">`,
+		`<rect x="1" y="1" width="298" height="36" class="fig-off fig-line" fill="${OFF}" stroke="${LINE}"/>`,
+		`<rect x="1" y="1" width="${width.toFixed(1)}" height="36" class="fig-on" fill="${ON}"/>`,
+		label(1, 54, "start", "0"),
+		label(at, 54, "middle", numbers.format(part)),
+		label(299, 54, "end", numbers.format(whole)),
+		...percent ? [
+			label(1, 70, "start", "0 %"),
+			label(at, 70, "middle", `${numbers.format(share * 100)} %`),
+			label(299, 70, "end", "100 %")
+		] : [],
+		`</svg>`
+	].join("");
+}
+// runtime/shared/blocks/render.ts
+const BLOCK_MESSAGES = {
+	de: {
+		credit: "Quelle: {source}. Lizenz: {licence}.",
+		code: "Code in {language}"
+	},
+	en: {
+		credit: "Source: {source}. Licence: {licence}.",
+		code: "Code in {language}"
+	}
+};
+const external = (url) => `<a href="${escape(url)}" rel="noopener">${escape(url)}</a>`;
+/** The credit of an image or a quotation: its source, as a link when it is a URL, and its licence. */
+function renderCredit(item, lang) {
+	if (item.source === void 0 || item.licence === void 0) return "";
+	const given = inLanguage(item.source, lang);
+	const source = isUrl(given) ? external(given) : escape(given);
+	return ` <span class="block-credit">${textsIn(BLOCK_MESSAGES, lang).credit.replace("{licence}", () => escape(item.licence ?? "")).replace("{source}", () => source)}</span>`;
+}
+function renderBlock(block, context) {
+	const { lang } = context;
+	const resolve = context.resolve ?? ((href) => href);
+	const plain = (text) => escape(inLanguage(text, lang));
+	const markdown = (text) => renderMarkdown(inLanguage(text, lang), resolve);
+	const inline = (text) => renderInline(inLanguage(text, lang), resolve);
+	switch (block.type) {
+		case "text": return `<div class="block-text">${markdown(block.text)}</div>`;
+		case "formula": return `<div class="block-formula">${renderFormula(inLanguage(block.formula, lang), true)}</div>`;
+		case "figure": {
+			const alt = inLanguage(block.alt, lang);
+			let picture = "";
+			if (block.draw?.kind === "hundred-grid") picture = hundredGrid(block.draw.filled, alt);
+			else if (block.draw?.kind === "bar") picture = bar(block.draw.part, block.draw.whole, alt, localeOf(lang));
+			else if (block.image !== void 0) picture = `<img src="${escape(context.href(block.image))}" alt="${escape(alt)}" loading="lazy" decoding="async">`;
+			return `<figure class="block-figure">${picture}<figcaption>${markdown(block.caption)}${renderCredit(block, lang)}</figcaption></figure>`;
+		}
+		case "labelled-figure": {
+			const markers = block.labels.map((label, index) => `<span class="block-marker" style="left: ${label.x}%; top: ${label.y}%" aria-hidden="true">${escape(markerOf(label, index))}</span>`).join("");
+			const named = block.labels.some((label) => label.marker !== void 0);
+			const item = (label, index) => named ? `<li><b>${escape(markerOf(label, index))}</b> ${plain(label.text)}</li>` : `<li>${plain(label.text)}</li>`;
+			const legend = block.legend === false ? "" : `<ol class="block-legend${named ? " block-legend-named" : ""}">${block.labels.map(item).join("")}</ol>`;
+			const caption = block.caption === void 0 ? "" : markdown(block.caption);
+			return [
+				`<figure class="block-figure block-labelled">`,
+				`<div class="block-labelled-image${context.sizeless?.(block.image) === true ? " block-labelled-fill" : ""}"><img src="${escape(context.href(block.image))}" alt="${plain(block.alt)}" loading="lazy" decoding="async">${markers}</div>`,
+				legend,
+				`<figcaption>${caption}${renderCredit(block, lang)}</figcaption>`,
+				`</figure>`
+			].join("");
+		}
+		case "table": {
+			const caption = plain(block.caption);
+			return `<div class="block-table" role="region" aria-label="${caption}" tabindex="0"><table><caption>${caption}</caption>${block.header === void 0 ? "" : `<thead><tr>${block.header.map((cell) => `<th scope="col">${inline(cell)}</th>`).join("")}</tr></thead>`}<tbody>${block.rows.map((row) => `<tr>${row.map((cell, index) => index === 0 && block.rowHeaders === true ? `<th scope="row">${inline(cell)}</th>` : `<td>${inline(cell)}</td>`).join("")}</tr>`).join("")}</tbody></table></div>`;
+		}
+		case "quote": {
+			const { author, work, year } = block.origin;
+			const origin = [
+				plain(author),
+				...work === void 0 ? [] : [`<cite>${plain(work)}</cite>`],
+				...year === void 0 ? [] : [typeof year === "number" ? String(year) : plain(year)]
+			].join(", ");
+			return `<figure class="block-quote"><blockquote>${markdown(block.text)}</blockquote><figcaption>— ${origin}.${renderCredit(block, lang)}</figcaption></figure>`;
+		}
+		case "code": {
+			const label = textsIn(BLOCK_MESSAGES, lang).code.replace("{language}", () => block.language);
+			const caption = block.caption === void 0 ? "" : `<figcaption>${plain(block.caption)}</figcaption>`;
+			return `<figure class="block-code"><pre role="region" aria-label="${escape(label)}" tabindex="0"><code class="hljs language-${block.language}">${highlight(block.code, block.language)}</code></pre>${caption}</figure>`;
+		}
+	}
+}
+/** The blocks as HTML, one after the other. */
+const renderMaterial = (blocks, context) => blocks.map((block) => renderBlock(block, context)).join("");
+export { highlight as a, hundredGrid as i, renderMaterial as n, bar as r, renderCredit as t };

package/dist/blocks.mjs

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

package/dist/check-CteIFN96.mjs

@@ -0,0 +1,254 @@
+import { c as textLanguages, t as escape } from "./html-mffkHGHh.mjs";
+import temml from "temml";
+import { Marked } from "marked";
+// runtime/shared/text/formula.ts
+globalThis.temml = temml;
+await import("temml/contrib/mhchem/mhchem.js");
+const allowed = /* @__PURE__ */ new Set([
+	"\\frac",
+	"\\cdot",
+	"\\times",
+	"\\div",
+	"\\%",
+	"\\text",
+	"\\sqrt",
+	"\\approx",
+	"\\pm",
+	"\\le",
+	"\\ge",
+	"\\neq",
+	"\\,",
+	"\\{",
+	"\\}",
+	"\\ce",
+	"\\pu"
+]);
+/** The commands of `tex` outside the arguments of \ce and \pu, which mhchem reads in its own notation. */
+function commands(tex) {
+	const found = [];
+	for (let at = 0; at < tex.length; at++) {
+		if (tex[at] !== "\\") continue;
+		const word = /^\\(?:[a-zA-Z]+|.)/.exec(tex.slice(at))?.[0] ?? "\\";
+		found.push(word);
+		at += word.length - 1;
+		if ((word === "\\ce" || word === "\\pu") && tex[at + 1] === "{") {
+			let depth = 0;
+			for (at++; at < tex.length; at++) if (tex[at] === "{") depth++;
+			else if (tex[at] === "}" && --depth === 0) break;
+		}
+	}
+	return found;
+}
+/** What is wrong with the formula `tex`, or undefined when it is in the command list and parses. */
+function formulaProblem(tex) {
+	const unknown = commands(tex).find((command) => !allowed.has(command));
+	if (unknown !== void 0) return `${unknown} is not in the formula command list; write the formula with the commands the schema lists ($defs/latex)`;
+	try {
+		temml.renderToString(tex, { throwOnError: true });
+		return;
+	} catch (error) {
+		return `the formula does not parse: ${(error instanceof Error ? error.message : String(error)).split("\n")[0]?.trim() ?? ""}`;
+	}
+}
+/** The formula as MathML: a <math> element, on its own line when `display`. */
+function renderFormula(tex, display) {
+	return temml.renderToString(tex, {
+		displayMode: display,
+		throwOnError: true
+	});
+}
+// runtime/shared/text/markdown.ts
+/** Where a link leads from the page being rendered; set for each render. */
+let resolveLink = (href) => href;
+const marked = new Marked({
+	gfm: true,
+	breaks: false,
+	extensions: [{
+		name: "math",
+		level: "inline",
+		start(source) {
+			const at = source.indexOf("$");
+			return at < 0 ? void 0 : at;
+		},
+		tokenizer(source) {
+			const match = /^\$((?:\\.|[^\\$\n])+?)\$/.exec(source);
+			return match === null ? void 0 : {
+				type: "math",
+				raw: match[0],
+				tex: match[1] ?? ""
+			};
+		},
+		renderer(token) {
+			return renderFormula(String(token["tex"]), false);
+		}
+	}],
+	renderer: {
+		html(token) {
+			return escape(token.text);
+		},
+		link({ href, tokens }) {
+			const text = this.parser.parseInline(tokens);
+			const external = /^https?:\/\//.test(href);
+			return `<a href="${escape(external ? href : resolveLink(href))}"${external ? " rel=\"noopener\"" : ""}>${text}</a>`;
+		}
+	}
+});
+/** What each construct outside restricted Markdown is, and what to use instead. */
+const NOT_ALLOWED = {
+	blockquote: "a quotation in Markdown; use a quote block",
+	code: "code in a text; use a code block",
+	codespan: "code in a text; use a code block, or $…$ for a formula",
+	def: "a link definition; write the link in place: [text](url)",
+	del: "strikethrough is not part of restricted Markdown",
+	hr: "a horizontal rule; structure the page with section blocks",
+	image: "an image in a text; use a figure block",
+	table: "a table in Markdown; use a table block",
+	checkbox: "a task list is not part of restricted Markdown"
+};
+const ALLOWED = /* @__PURE__ */ new Set([
+	"space",
+	"paragraph",
+	"text",
+	"list",
+	"list_item",
+	"strong",
+	"em",
+	"link",
+	"escape",
+	"br",
+	"math"
+]);
+function children(token) {
+	const nested = [];
+	if ("tokens" in token && Array.isArray(token.tokens)) nested.push(...token.tokens);
+	if (token.type === "list") nested.push(...token.items);
+	return nested;
+}
+/** The problems, formulas and links of a text in restricted Markdown. */
+function inspect(source) {
+	const found = {
+		problems: [],
+		formulas: [],
+		links: []
+	};
+	const lineOf = (raw) => {
+		const at = source.indexOf(raw.trimStart());
+		return at < 0 ? 0 : source.slice(0, at).split("\n").length - 1;
+	};
+	const add = (raw, message) => {
+		if (!found.problems.some((problem) => problem.message === message)) found.problems.push({
+			line: lineOf(raw),
+			message
+		});
+	};
+	const visit = (tokens) => {
+		for (const token of tokens) {
+			if (token.type === "heading") {
+				const title = token.text.trim();
+				add(token.raw, `a Markdown heading ("${title}"); use a section block with the title "${title}"`);
+			} else if (token.type === "html") {
+				const tag = /^<\/?([a-zA-Z][\w-]*)/.exec(token.raw.trim())?.[1] ?? "";
+				if (!found.problems.some((problem) => problem.message.startsWith("raw HTML"))) add(token.raw, `raw HTML (<${tag}>) is not allowed; write restricted Markdown: **bold**, *italics*, lists, links`);
+			} else if (token.type === "math") {
+				const tex = String(token.tex);
+				found.formulas.push(tex);
+				const problem = formulaProblem(tex);
+				if (problem !== void 0) add(token.raw, `$${tex}$: ${problem}`);
+			} else if (token.type === "link") {
+				const href = token.href;
+				if (/^https?:\/\/\S+$/.test(href) || href.startsWith("/")) found.links.push(href);
+				else add(token.raw, `the link ${href} leads nowhere a learner can follow; link to https://… or to a page of the app: /<chapter>/<page>/`);
+			} else if (!ALLOWED.has(token.type)) add(token.raw, NOT_ALLOWED[token.type] ?? `${token.type} is not part of restricted Markdown`);
+			visit(children(token));
+		}
+	};
+	visit(marked.lexer(source));
+	return found;
+}
+/** A text in restricted Markdown as HTML; links to pages of the app go through `resolve`. */
+function renderMarkdown(source, resolve) {
+	resolveLink = resolve;
+	return marked.parse(source, { async: false }).trim();
+}
+/** A short text in restricted Markdown as HTML without a paragraph around it, e.g. a table cell or a caption. */
+function renderInline(source, resolve) {
+	resolveLink = resolve;
+	return marked.parseInline(source, { async: false }).trim();
+}
+/** A plain text as HTML. */
+const plain = escape;
+const FORMULA = /\$((?:\\.|[^\\$\n])+?)\$/g;
+/** A plain text as HTML in which only $…$ is a formula (MathML); everything else stays text, as in a quiz. */
+function renderWithFormulas(text) {
+	let html = "";
+	let from = 0;
+	for (const match of text.matchAll(FORMULA)) {
+		html += escape(text.slice(from, match.index)) + renderFormula(match[1] ?? "", false);
+		from = match.index + match[0].length;
+	}
+	return html + escape(text.slice(from));
+}
+/** What is wrong with the formulas $…$ of a plain text; none when each is in the command list and parses. */
+function formulaProblems(text) {
+	return [...text.matchAll(FORMULA)].flatMap((match) => {
+		const problem = formulaProblem(match[1] ?? "");
+		return problem === void 0 ? [] : [`$${match[1]}$: ${problem}`];
+	});
+}
+/** The first HTML tag in a plain text, if it has one. */
+function htmlTag(text) {
+	return /<\/?([a-zA-Z][\w-]*)[^>]*>/.exec(text)?.[1];
+}
+// runtime/shared/text/check.ts
+/** A URL as the source of a credit: the same in every language. */
+const isUrl = (text) => /^https?:\/\/\S+$/.test(text);
+/** The problems of the text `value` of the given kind in `languages`, declared in `declaredIn`, and its links. */
+function checkText(value, kind, languages, declaredIn) {
+	const findings = [];
+	const links = [];
+	const neutral = kind === "latex" || kind === "name" || kind === "credit" && typeof value === "string" && isUrl(value);
+	const { texts, problems } = textLanguages(value, languages, neutral, declaredIn);
+	for (const problem of problems) findings.push({
+		path: [],
+		lang: problem.lang,
+		message: problem.message
+	});
+	for (const { lang, text, keyed } of texts) {
+		const at = keyed ? [lang] : [];
+		if (kind === "latex") {
+			const problem = formulaProblem(text);
+			if (problem !== void 0) findings.push({
+				path: at,
+				...keyed ? { lang } : {},
+				message: problem
+			});
+			continue;
+		}
+		if (kind === "plain" || kind === "name" || kind === "credit") {
+			const tag = htmlTag(text);
+			if (tag !== void 0) findings.push({
+				path: at,
+				lang,
+				message: `raw HTML (<${tag}>) is not allowed; write restricted Markdown: **bold**, *italics*, lists, links`
+			});
+			continue;
+		}
+		const found = inspect(text);
+		for (const problem of found.problems) findings.push({
+			path: at,
+			lang,
+			line: problem.line,
+			message: problem.message
+		});
+		for (const href of found.links.filter((link) => link.startsWith("/"))) links.push({
+			path: at,
+			lang,
+			href
+		});
+	}
+	return {
+		findings,
+		links
+	};
+}
+export { inspect as a, renderMarkdown as c, formulaProblems as i, renderWithFormulas as l, isUrl as n, plain as o, FORMULA as r, renderInline as s, checkText as t, renderFormula as u };

package/dist/content-DO6oEJxj.mjs

@@ -0,0 +1,140 @@
+import { t as checkText } from "./check-CteIFN96.mjs";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { LineCounter, isNode, parseDocument } from "yaml";
+// runtime/shared/content.ts
+/** `["blocks", 0, "text"]` as `blocks[0].text`. */
+function pathText(path) {
+	return path.map((part, index) => typeof part === "number" ? `[${part}]` : index === 0 ? part : `.${part}`).join("");
+}
+const get = (value, path) => path.reduce((at, part) => typeof at === "object" && at !== null ? at[part] : void 0, value);
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Collects the problems, one line each, without repeating one. */
+var Problems = class {
+	lines = [];
+	add(line) {
+		if (!this.lines.includes(line)) this.lines.push(line);
+	}
+	/** A problem at `path` in `yaml` (in `lang`), `offset` lines below the line of the value there. */
+	at(yaml, path, message, lang, offset = 0) {
+		const line = lineOf(yaml, path, offset);
+		const shown = lang !== void 0 && path.at(-1) === lang ? path.slice(0, -1) : path;
+		const where = shown.length === 0 ? "" : ` ${pathText(shown)}${lang === void 0 ? "" : ` (${lang})`}:`;
+		this.add(`${yaml.file}${line === void 0 ? "" : `:${line}`}:${where} ${message}`);
+	}
+	file(file, message) {
+		this.add(`${file}: ${message}`);
+	}
+};
+/** The line of the value at `path`, or of the nearest value around it; a block scalar's text starts a line lower. */
+function lineOf(yaml, path, offset) {
+	for (let length = path.length; length >= 0; length--) {
+		const node = yaml.doc.getIn(path.slice(0, length), true);
+		if (!isNode(node) || node.range === void 0 || node.range === null) continue;
+		const block = "type" in node && (node.type === "BLOCK_LITERAL" || node.type === "BLOCK_FOLDED");
+		return yaml.lines.linePos(node.range[0]).line + (length === path.length ? offset + (block && offset > 0 ? 1 : block ? 1 : 0) : 0);
+	}
+}
+/** Reads a YAML file of the content (`file` from the app's root); undefined, with its problems, when it is not valid YAML. */
+function readYaml(root, file, problems) {
+	const lines = new LineCounter();
+	const doc = parseDocument(readFileSync(join(root, file), "utf8"), {
+		lineCounter: lines,
+		prettyErrors: false
+	});
+	if (doc.errors.length > 0) {
+		for (const error of doc.errors) {
+			const line = lines.linePos(error.pos[0]).line;
+			problems.add(`${file}:${line}: not valid YAML: ${error.message.split("\n")[0] ?? ""}`);
+		}
+		return;
+	}
+	return {
+		file,
+		doc,
+		lines,
+		value: doc.toJS()
+	};
+}
+/** The schema's errors as problems: one per cause, the branches of texts and blocks folded. */
+function schemaProblems(yaml, errors, problems, describe) {
+	const pathOf = (pointer) => pointer.split("/").slice(1).map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~")).map((part) => /^\d+$/.test(part) ? Number(part) : part);
+	const texts = errors.filter((error) => error.keyword === "anyOf").map((error) => error.instancePath);
+	const underText = (error) => texts.some((text) => error.instancePath === text || error.instancePath.startsWith(`${text}/`));
+	for (const error of errors) {
+		const path = pathOf(error.instancePath);
+		const value = get(yaml.value, path);
+		const described = describe?.(error, path, value);
+		if (described !== void 0) {
+			if (described !== null) problems.at(yaml, described.path ?? path, described.message, described.lang);
+			continue;
+		}
+		switch (error.keyword) {
+			case "if": break;
+			case "anyOf":
+				if (typeof value === "string") problems.at(yaml, path, "must not be empty");
+				else if (isObject(value)) {
+					for (const [lang, text] of Object.entries(value)) if (typeof text !== "string") problems.at(yaml, path, "must be a text", lang);
+					else if (text.trim() === "") problems.at(yaml, path, "must not be empty", lang);
+					else if (!/^[a-z]{2}$/.test(lang)) problems.at(yaml, path, `${lang} is not a language code; use two letters, e.g. de, en`);
+				} else problems.at(yaml, path, "must be a text, or a map of texts by language: { de: …, en: … }");
+				break;
+			case "required":
+			case "dependentRequired":
+				problems.at(yaml, path, `${String(error.params["missingProperty"])} is missing`);
+				break;
+			case "additionalProperties":
+				problems.at(yaml, path, `${String(error.params["additionalProperty"])} is not allowed here`);
+				break;
+			case "unevaluatedProperties":
+				problems.at(yaml, path, `${String(error.params["unevaluatedProperty"])} is not allowed here`);
+				break;
+			case "enum":
+				problems.at(yaml, path, `must be one of ${error.params["allowedValues"].join(", ")}`);
+				break;
+			case "pattern":
+				if (underText(error)) break;
+				if (error.schemaPath.includes("/id/") || error.schemaPath.startsWith("#/$defs/id")) problems.at(yaml, path, `use lower-case letters, digits and hyphens, e.g. "prozentwert"`);
+				else if (String(error.params["pattern"]) === "\\S") problems.at(yaml, path, "must not be empty");
+				else problems.at(yaml, path, `must match ${String(error.params["pattern"])}`);
+				break;
+			case "type":
+			case "minLength":
+				if (!underText(error)) problems.at(yaml, path, error.message ?? "is not valid");
+				break;
+			case "minItems":
+				problems.at(yaml, path, "must not be empty");
+				break;
+			default: if (!underText(error)) problems.at(yaml, path, error.message ?? "is not valid");
+		}
+	}
+}
+/** The checks of the texts: languages, raw HTML, Markdown, formulas. */
+var Texts = class {
+	links = [];
+	languages;
+	problems;
+	constructor(languages, problems) {
+		this.languages = languages;
+		this.problems = problems;
+	}
+	/**
+	* The text at `path` of `yaml`: a plain text, restricted Markdown, a formula, a name (a person, a work), or the source
+	* of a credit (a URL or a citation); a formula, a name or a URL given as a string is the same in every language, a
+	* citation is a plain text.
+	*/
+	check(yaml, path, kind) {
+		const value = get(yaml.value, path);
+		if (value === void 0) return;
+		const { findings, links } = checkText(value, kind, this.languages);
+		for (const finding of findings) this.problems.at(yaml, [...path, ...finding.path], finding.message, finding.lang, finding.line);
+		for (const link of links) this.links.push({
+			yaml,
+			path: [...path, ...link.path],
+			lang: link.lang,
+			offset: 0,
+			href: link.href
+		});
+	}
+};
+export { lineOf as a, schemaProblems as c, isObject as i, Texts as n, pathText as o, get as r, readYaml as s, Problems as t };