@kadal/deck 0.0.0-stage → 0.1.0

package/dist/export/index.js

@@ -0,0 +1,251 @@
+import { POSTER_DEFAULT_SIZE, posterName } from "../core/poster.js";
+import { splitDeck } from "../compiler/split.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region src/export/index.ts
+const DEFAULT_POSTER_WAIT = 5e3;
+/** Every embedded page in the deck that has no poster of its own, with the size to capture. */
+function posterJobs(deckDir, config, entry = "deck.mdx") {
+	const file = join(deckDir, entry);
+	if (!existsSync(file)) return [];
+	const split = splitDeck(readFileSync(file, "utf8"), {
+		file,
+		resolveInclude: (path, from) => {
+			const inc = join(dirname(from), path);
+			return existsSync(inc) ? {
+				file: inc,
+				text: readFileSync(inc, "utf8")
+			} : null;
+		}
+	});
+	const jobs = /* @__PURE__ */ new Map();
+	const add = (url, width, height, capture = url, wait = DEFAULT_POSTER_WAIT) => {
+		const name = posterName(url, width, height);
+		if (!jobs.has(name)) jobs.set(name, {
+			url,
+			capture,
+			width,
+			height,
+			file: name,
+			wait
+		});
+	};
+	for (const s of split.slides) {
+		const fm = s.frontmatter;
+		const layout = typeof fm.layout === "string" ? fm.layout : "";
+		if (/^iframe(-left|-right)?$/.test(layout) && typeof fm.url === "string" && !fm.poster) {
+			const half = layout !== "iframe";
+			add(fm.url, half ? Math.round(config.width / 2) : config.width, config.height, typeof fm.posterUrl === "string" ? fm.posterUrl : fm.url, typeof fm.posterWait === "number" ? fm.posterWait : DEFAULT_POSTER_WAIT);
+		}
+		for (const m of s.content.matchAll(/<Iframe\b([^>]*)>/g)) {
+			const attrs = m[1] ?? "";
+			if (/\bposter=/.test(attrs)) continue;
+			const src = /\bsrc=["']([^"']+)["']/.exec(attrs)?.[1];
+			const capture = /\bposterUrl=["']([^"']+)["']/.exec(attrs)?.[1];
+			const wait = /\bposterWait=\{?(\d+)\}?/.exec(attrs)?.[1];
+			if (src && /^https?:\/\//.test(src)) add(src, POSTER_DEFAULT_SIZE[0], POSTER_DEFAULT_SIZE[1], capture ?? src, wait ? Number(wait) : DEFAULT_POSTER_WAIT);
+		}
+	}
+	return [...jobs.values()];
+}
+/**
+* Capture the posters that are missing (or all of them with `refresh`). WebGL pages render
+* through SwiftShader; each page gets its job's `wait` after load for maps and fonts.
+*/
+async function capturePosters(deckDir, jobs, { refresh = false, log = console.log } = {}) {
+	const todo = jobs.filter((j) => refresh || !existsSync(join(deckDir, "public", j.file)));
+	if (!todo.length) return 0;
+	const { chromium } = await import("playwright");
+	const browser = await chromium.launch({ args: [
+		"--use-gl=angle",
+		"--use-angle=swiftshader",
+		"--enable-unsafe-swiftshader",
+		"--ignore-gpu-blocklist"
+	] });
+	let done = 0;
+	try {
+		for (const j of todo) {
+			const target = join(deckDir, "public", j.file);
+			mkdirSync(dirname(target), { recursive: true });
+			const context = await browser.newContext({
+				viewport: {
+					width: j.width,
+					height: j.height
+				},
+				deviceScaleFactor: 1
+			});
+			const page = await context.newPage();
+			try {
+				log(`poster ${j.capture} at ${j.width}×${j.height}${j.capture !== j.url ? ` (for ${j.url})` : ""}`);
+				await page.goto(j.capture, {
+					waitUntil: "domcontentloaded",
+					timeout: 6e4
+				});
+				await page.waitForTimeout(j.wait);
+				await page.screenshot({
+					path: target,
+					type: "jpeg",
+					quality: 86
+				});
+				log(`       → public/${j.file}`);
+				done++;
+			} catch (e) {
+				log(`       failed: ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`);
+			} finally {
+				await context.close();
+			}
+		}
+	} finally {
+		await browser.close();
+	}
+	return done;
+}
+async function exportDeck(options) {
+	const log = options.log ?? console.log;
+	const { chromium } = await import("playwright");
+	mkdirSync(options.outDir, { recursive: true });
+	const browser = await chromium.launch();
+	const result = {
+		files: [],
+		pages: 0
+	};
+	try {
+		const page = await (await browser.newContext({
+			deviceScaleFactor: options.scale ?? 2,
+			viewport: {
+				width: 1920,
+				height: 1080
+			}
+		})).newPage();
+		const url = new URL(options.url);
+		url.searchParams.set("print-pdf", "");
+		log(`open  ${url}`);
+		await page.goto(url.toString(), { waitUntil: "networkidle" });
+		await page.waitForSelector(".deck-print-pages[data-ready]", { timeout: 12e4 });
+		await page.evaluate(() => document.fonts.ready);
+		await page.waitForTimeout(800);
+		const dims = await page.evaluate(() => {
+			const el = document.querySelector(".deck-print-page");
+			return {
+				width: el?.offsetWidth ?? 1920,
+				height: el?.offsetHeight ?? 1080,
+				pages: document.querySelectorAll(".deck-print-page").length
+			};
+		});
+		result.pages = dims.pages;
+		log(`pages ${dims.pages} at ${dims.width}×${dims.height}`);
+		if (options.pdf !== false) {
+			const path = join(options.outDir, `${options.slug}.pdf`);
+			await page.emulateMedia({ media: "print" });
+			await page.pdf({
+				path,
+				width: `${dims.width}px`,
+				height: `${dims.height}px`,
+				printBackground: true,
+				preferCSSPageSize: true,
+				margin: {
+					top: 0,
+					right: 0,
+					bottom: 0,
+					left: 0
+				}
+			});
+			await page.emulateMedia({ media: "screen" });
+			result.files.push({
+				kind: "pdf",
+				path,
+				size: readFileSync(path).byteLength
+			});
+			log(`pdf   ${path}`);
+		}
+		if (options.png || options.pptx) {
+			const pngDir = join(options.outDir, "png");
+			mkdirSync(pngDir, { recursive: true });
+			const pages = await page.$$(".deck-print-page");
+			const shots = [];
+			for (let i = 0; i < pages.length; i++) {
+				const el = pages[i];
+				await el.scrollIntoViewIfNeeded();
+				const path = join(pngDir, `${String(i + 1).padStart(3, "0")}.png`);
+				await el.screenshot({
+					path,
+					type: "png"
+				});
+				const notes = await el.$eval(".deck-print-notes", (n) => n.innerText).catch(() => "");
+				shots.push({
+					path,
+					notes
+				});
+			}
+			if (options.png) {
+				for (const s of shots) result.files.push({
+					kind: "png",
+					path: s.path,
+					size: readFileSync(s.path).byteLength
+				});
+				log(`png   ${shots.length} files in ${pngDir}`);
+			}
+			if (options.pptx) {
+				const path = join(options.outDir, `${options.slug}.pptx`);
+				await writePptx(path, shots, dims.width, dims.height, options.slug);
+				result.files.push({
+					kind: "pptx",
+					path,
+					size: readFileSync(path).byteLength
+				});
+				log(`pptx  ${path}`);
+			}
+		}
+	} finally {
+		await browser.close();
+	}
+	if (options.upload) for (const f of result.files) {
+		if (f.kind === "png") continue;
+		const target = `${options.upload.replace(/\/$/, "")}/api/decks/${options.slug}/exports?kind=${f.kind}`;
+		const body = readFileSync(f.path);
+		const res = await fetch(target, {
+			method: "POST",
+			headers: {
+				"content-type": f.kind === "pdf" ? "application/pdf" : "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+				"content-length": String(body.byteLength),
+				...options.adminKey ? { authorization: `Bearer ${options.adminKey}` } : {}
+			},
+			body
+		});
+		const json = await res.json().catch(() => ({}));
+		if (!res.ok) log(`upload ${f.kind} failed: ${res.status} ${json.error ?? ""}`);
+		else {
+			f.uploaded = json.url;
+			log(`upload ${f.kind} → ${json.url}`);
+		}
+	}
+	return result;
+}
+async function writePptx(path, shots, width, height, title) {
+	const mod = await import("pptxgenjs");
+	const pptx = new (mod.default ?? mod)();
+	const w = width / 96;
+	const h = height / 96;
+	pptx.defineLayout({
+		name: "deck",
+		width: w,
+		height: h
+	});
+	pptx.layout = "deck";
+	pptx.title = title;
+	for (const s of shots) {
+		const slide = pptx.addSlide();
+		slide.addImage({
+			data: `image/png;base64,${readFileSync(s.path).toString("base64")}`,
+			x: 0,
+			y: 0,
+			w,
+			h
+		});
+		if (s.notes.trim()) slide.addNotes(s.notes.trim());
+	}
+	const data = await pptx.write({ outputType: "nodebuffer" });
+	writeFileSync(path, data);
+}
+//#endregion
+export { capturePosters, exportDeck, posterJobs };

package/dist/export/run.js

@@ -0,0 +1,81 @@
+import { capturePosters, exportDeck, posterJobs } from "./index.js";
+import { runVite, spawnVite } from "../cli/vite.js";
+import { basename, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/export/run.ts
+/** `kadal-deck export [flags]` in a deck folder. Returns once every file is written. */
+async function runExport(args, cwd = process.cwd()) {
+	const has = (f) => args.includes(f);
+	const val = (f) => {
+		const i = args.indexOf(f);
+		return i >= 0 ? args[i + 1] : void 0;
+	};
+	const slug = val("--slug") ?? basename(cwd);
+	/** The id the host keys this deck by (a published deck's room); defaults to the slug. */
+	const room = val("--room") ?? slug;
+	const outDir = resolve(cwd, val("--out") ?? "export");
+	let url = val("--url");
+	let preview = null;
+	if (!has("--no-posters")) {
+		const size = await deckSize();
+		const jobs = posterJobs(cwd, size);
+		const n = await capturePosters(cwd, jobs, { refresh: has("--refresh-posters") });
+		console.log(`poster ${jobs.length} embedded page(s), ${n} captured`);
+		if (has("--posters")) return;
+	}
+	/** The authored stage size, from deck.config.ts when it sets one. */
+	async function deckSize() {
+		try {
+			const mod = await import(pathToFileURL(resolve(cwd, "deck.config.ts")).href);
+			return {
+				width: mod.config?.width ?? 1920,
+				height: mod.config?.height ?? 1080
+			};
+		} catch {
+			return {
+				width: 1920,
+				height: 1080
+			};
+		}
+	}
+	if (!url) {
+		console.log("build  vite build");
+		await runVite(cwd, ["build"]);
+		const port = 4173 + Math.floor(Math.random() * 200);
+		preview = spawnVite(cwd, [
+			"preview",
+			"--port",
+			String(port),
+			"--strictPort"
+		], "ignore");
+		url = `http://localhost:${port}/${slug}/`;
+		await waitForServer(url, Date.now() + 2e4);
+	}
+	/** Poll until the preview answers (or the deadline passes) — one request every 200 ms. */
+	async function waitForServer(target, deadline) {
+		try {
+			if ((await fetch(target)).ok) return;
+		} catch {}
+		if (Date.now() >= deadline) return;
+		await new Promise((r) => setTimeout(r, 200));
+		return waitForServer(target, deadline);
+	}
+	try {
+		const result = await exportDeck({
+			url,
+			outDir,
+			slug: room,
+			pdf: !has("--no-pdf"),
+			png: has("--png"),
+			pptx: has("--pptx"),
+			scale: Number(val("--scale") ?? 2),
+			upload: has("--upload") ? val("--upload")?.startsWith("http") ? val("--upload") : process.env.DECK_HOST ?? "https://deck.kadal.cc" : null,
+			adminKey: process.env.DECK_ADMIN_KEY ?? null
+		});
+		console.log(`\ndone   ${result.pages} pages, ${result.files.length} file(s)`);
+	} finally {
+		preview?.kill();
+	}
+}
+//#endregion
+export { runExport };

package/dist/glossary/model.d.ts

@@ -0,0 +1,81 @@
+//#region src/glossary/model.d.ts
+/**
+ * ─────────────────────────────────────────────────────────────────────────────
+ * THE GLOSSARY MODEL  —  pure string work, shared by the compiler and the browser
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * A deck's key concepts and abbreviations live in one `glossary.yaml` beside `deck.mdx`. The
+ * compiler links the first mention of each term on every slide (`compiler/rehype-glossary.ts`),
+ * `<Term>` links one by hand, and the runtime shows the definition in a card after a short hover
+ * (`components/Term.tsx`). Both sides import this file, so they agree on ids, on what counts as a
+ * mention, and on how a definition's inline Markdown becomes HTML. No Node imports here.
+ *
+ * The matcher follows the one that links Paadam's notes (apps/paadam/mdx/glossary.ts): longest
+ * name first, whole words only, an optional plural — with one rule tightened for slides, where
+ * abbreviations dominate: a name with no lowercase letter (GIS, WGS84) or shorter than four
+ * characters matches in its exact case only, so "who" never becomes the WHO.
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+export interface GlossaryEntry {
+  /** Stable slug of the name: what `<Term id>`, `see:` and the room's reveal message carry. */
+  id: string;
+  /** The term as the card titles it, and the first string the matcher looks for. */
+  name: string;
+  /** An abbreviation's expansion, shown under the title. */
+  full: string | null;
+  /** Other spellings that are the same term. */
+  aliases: string[];
+  /** A category chip: "Projection", "Statistics". */
+  tag: string | null;
+  link: {
+    href: string;
+    label: string;
+  } | null;
+  /** Ids of related entries, offered as chips that swap the card. */
+  see: string[];
+  /** False keeps the term out of automatic linking; `<Term>` still finds it. */
+  auto: boolean;
+  /** The definition and the optional second paragraph, as inline HTML (see `inlineHtml`). */
+  html: {
+    def: string;
+    more: string | null;
+  };
+}
+/** Deck-level options, from the headmatter's `glossary:` key (a path, `false`, or a mapping). */
+export interface GlossaryOptions {
+  /** The glossary file, relative to the deck file; null switches the feature off. */
+  src: string | null;
+  /** Link the first mention on each slide, or every mention. */
+  repeat: "first" | "all";
+  /** Headings: only for terms the slide's body never mentions, always, or never. */
+  headings: "fallback" | boolean;
+  /** Extra component names whose children are left alone. */
+  skip: string[];
+  /** Milliseconds the pointer rests on a term before its card opens. */
+  delay: number;
+  /** Whether the presenter's reveals start out shared with the room. */
+  sync: boolean;
+}
+export declare const DEFAULT_GLOSSARY: GlossaryOptions;
+/** "Plus Code" → "plus-code", "WGS84" → "wgs84". */
+export declare function termId(name: string): string;
+export interface TermMatch {
+  entry: GlossaryEntry;
+  index: number;
+  text: string;
+}
+export interface TermMatcher {
+  /** Every mention in `text`, left to right, never overlapping. */
+  find(text: string): TermMatch[];
+  /** The entry a whole string names (by name, alias or id), for `<Term>UTM</Term>`. */
+  resolve(text: string): GlossaryEntry | undefined;
+}
+export declare function buildMatcher(entries: GlossaryEntry[]): TermMatcher;
+/**
+ * A definition's inline Markdown as HTML: **bold**, *emphasis*, `code`, [links](https://…) and
+ * $maths$. Everything else is escaped, so the result is safe to set as innerHTML. `math` renders
+ * TeX (the Vite plugin passes KaTeX at build time, which keeps KaTeX out of the browser bundle);
+ * without it, maths shows as its source.
+ */
+export declare function inlineHtml(source: string, math?: (tex: string) => string): string;
+//#endregion

package/dist/glossary/model.js

@@ -0,0 +1,156 @@
+//#region src/glossary/model.ts
+const DEFAULT_GLOSSARY = {
+	src: "glossary.yaml",
+	repeat: "first",
+	headings: "fallback",
+	skip: [],
+	delay: 700,
+	sync: false
+};
+/** Normalise the headmatter's `glossary:` value over a base (the defaults, or an earlier layer). */
+function glossaryOptions(value, base = DEFAULT_GLOSSARY) {
+	if (value === void 0 || value === null || value === true) return { ...base };
+	if (value === false) return {
+		...base,
+		src: null
+	};
+	if (typeof value === "string") return {
+		...base,
+		src: value
+	};
+	if (typeof value !== "object" || Array.isArray(value)) return { ...base };
+	const v = value;
+	const out = { ...base };
+	if (typeof v.src === "string") out.src = v.src;
+	else if (v.src === false || v.src === null) out.src = null;
+	if (v.repeat === "first" || v.repeat === "all") out.repeat = v.repeat;
+	if (v.headings === "fallback" || typeof v.headings === "boolean") out.headings = v.headings;
+	if (Array.isArray(v.skip)) out.skip = v.skip.map(String);
+	if (typeof v.delay === "number" && v.delay >= 0) out.delay = v.delay;
+	if (typeof v.sync === "boolean") out.sync = v.sync;
+	return out;
+}
+/** "Plus Code" → "plus-code", "WGS84" → "wgs84". */
+function termId(name) {
+	return name.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+/** An id for a one-off `<Term def>`: stable across builds and screens, distinct from any slug. */
+function adhocId(text) {
+	let h = 2166136261;
+	for (let i = 0; i < text.length; i++) {
+		h ^= text.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return `~${(h >>> 0).toString(36)}`;
+}
+/** A name that must match in its exact case: an abbreviation, or too short to trust otherwise. */
+function isExactCase(word) {
+	return word.length < 4 || !/\p{Ll}/u.test(word);
+}
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const WORD = /[\p{L}\p{N}_]/u;
+function buildMatcher(entries) {
+	const byKey = /* @__PURE__ */ new Map();
+	const byId = /* @__PURE__ */ new Map();
+	const auto = [];
+	for (const entry of entries) {
+		byId.set(entry.id, entry);
+		for (const word of [entry.name, ...entry.aliases]) {
+			const key = word.toLowerCase();
+			if (key.length < 2 || byKey.has(key)) continue;
+			byKey.set(key, {
+				entry,
+				word
+			});
+			if (entry.auto) auto.push(word);
+		}
+	}
+	auto.sort((a, b) => b.length - a.length);
+	const re = auto.length ? new RegExp(`(^|[^\\p{L}\\p{N}_])(${auto.map(escapeRe).join("|")})(e?s)?(?![\\p{L}\\p{N}_])`, "giu") : null;
+	const lookup = (stem, requireAuto) => {
+		const hit = byKey.get(stem.toLowerCase());
+		if (!hit || requireAuto && !hit.entry.auto) return void 0;
+		if (isExactCase(hit.word) && hit.word !== stem) return void 0;
+		return hit;
+	};
+	return {
+		find(text) {
+			if (!re) return [];
+			const out = [];
+			re.lastIndex = 0;
+			for (let m = re.exec(text); m; m = re.exec(text)) {
+				const lead = m[1] ?? "";
+				const stem = m[2] ?? "";
+				const plural = m[3] ?? "";
+				const index = m.index + lead.length;
+				const hit = lookup(stem, true);
+				const next = text[index + stem.length + plural.length] ?? "";
+				if (hit && !((lead === "-" || next === "-") && !isExactCase(hit.word))) out.push({
+					entry: hit.entry,
+					index,
+					text: stem + plural
+				});
+				else {
+					re.lastIndex = index + 1;
+					while (re.lastIndex < text.length && WORD.test(text[re.lastIndex])) re.lastIndex++;
+				}
+			}
+			return out;
+		},
+		resolve(text) {
+			const t = text.replace(/\s+/g, " ").trim();
+			if (!t) return void 0;
+			const direct = byId.get(t) ?? lookup(t, false)?.entry;
+			if (direct) return direct;
+			for (const cut of [/s$/i, /es$/i]) {
+				const stem = t.replace(cut, "");
+				if (stem !== t) {
+					const hit = lookup(stem, false);
+					if (hit) return hit.entry;
+				}
+			}
+			return byId.get(termId(t));
+		}
+	};
+}
+const escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const SAFE_HREF = /^(https?:|mailto:|#|\/|\.{1,2}\/)/i;
+/**
+* A definition's inline Markdown as HTML: **bold**, *emphasis*, `code`, [links](https://…) and
+* $maths$. Everything else is escaped, so the result is safe to set as innerHTML. `math` renders
+* TeX (the Vite plugin passes KaTeX at build time, which keeps KaTeX out of the browser bundle);
+* without it, maths shows as its source.
+*/
+function inlineHtml(source, math) {
+	const re = /`([^`]+)`|\$([^$\n]+)\$|\*\*([^*]+)\*\*|\*([^*\n]+)\*|\[([^\]]+)\]\(([^)\s]+)\)/g;
+	let out = "";
+	let last = 0;
+	for (const m of source.matchAll(re)) {
+		const start = m.index ?? 0;
+		out += escapeHtml(source.slice(last, start));
+		if (m[1] !== void 0) out += `<code>${escapeHtml(m[1])}</code>`;
+		else if (m[2] !== void 0) {
+			let html = "";
+			try {
+				html = math ? math(m[2]) : "";
+			} catch {
+				html = "";
+			}
+			out += html || `<code class="deck-term-tex">${escapeHtml(m[2])}</code>`;
+		} else if (m[3] !== void 0) out += `<strong>${inlineHtml(m[3], math)}</strong>`;
+		else if (m[4] !== void 0) out += `<em>${inlineHtml(m[4], math)}</em>`;
+		else if (m[5] !== void 0 && m[6] !== void 0) out += SAFE_HREF.test(m[6]) ? `<a href="${escapeHtml(m[6])}" target="_blank" rel="noopener noreferrer">${inlineHtml(m[5], math)}</a>` : inlineHtml(m[5], math);
+		last = start + m[0].length;
+	}
+	return out + escapeHtml(source.slice(last));
+}
+/** "epsg.io" from a link, for the card's source line. */
+function linkLabel(href) {
+	try {
+		return new URL(href, "https://x.invalid").hostname.replace(/^www\./, "") || href;
+	} catch {
+		return href;
+	}
+}
+//#endregion
+export { DEFAULT_GLOSSARY, adhocId, buildMatcher, glossaryOptions, inlineHtml, isExactCase, linkLabel, termId };

package/dist/glossary/parse.d.ts

@@ -0,0 +1,27 @@
+import { GlossaryEntry } from "./model.js";
+//#region src/glossary/parse.d.ts
+/**
+ * `glossary.yaml` → entries. The key is the term as the card titles it; the value is either the
+ * definition itself or a mapping:
+ *
+ *   GNSS: Satellite positioning — GPS, NavIC, Galileo and the rest.
+ *   UTM:
+ *     full: Universal Transverse Mercator
+ *     def: Sixty projections, each 6° wide, that turn latitude and longitude into **metres**.
+ *     more: Chennai sits in zone 44N.
+ *     aliases: [UTM zone 44N]
+ *     tag: Projection
+ *     link: https://epsg.io/32644          # or { href, label }
+ *     see: [WGS84, EPSG]
+ *     auto: false                           # never linked automatically; <Term> still finds it
+ *
+ * Definitions take inline Markdown and $maths$; both are rendered here, at build time, so the
+ * browser receives finished HTML. Problems an author should hear about come back as `warnings`
+ * rather than failing the build: a talk should never stop compiling over a glossary typo.
+ */
+export interface ParsedGlossary {
+  entries: GlossaryEntry[];
+  warnings: string[];
+}
+export declare function parseGlossary(source: string, where: string, math?: (tex: string) => string): ParsedGlossary;
+//#endregion

package/dist/glossary/parse.js

@@ -0,0 +1,90 @@
+import { inlineHtml, linkLabel, termId } from "./model.js";
+import YAML from "yaml";
+//#region src/glossary/parse.ts
+const list = (value) => Array.isArray(value) ? value.map((v) => String(v).trim()).filter(Boolean) : typeof value === "string" ? value.split(/\s*[,;]\s*/).map((s) => s.trim()).filter(Boolean) : [];
+const text = (value) => typeof value === "string" || typeof value === "number" ? String(value).replace(/\s+/g, " ").trim() || null : null;
+function parseGlossary(source, where, math) {
+	const warnings = [];
+	let doc;
+	try {
+		doc = YAML.parse(source);
+	} catch (e) {
+		return {
+			entries: [],
+			warnings: [`${where}: ${e instanceof Error ? e.message : String(e)}`]
+		};
+	}
+	if (doc === null || doc === void 0) return {
+		entries: [],
+		warnings
+	};
+	if (typeof doc !== "object" || Array.isArray(doc)) return {
+		entries: [],
+		warnings: [`${where}: the glossary must be a YAML mapping of terms`]
+	};
+	const entries = [];
+	const pendingSee = /* @__PURE__ */ new Map();
+	const ids = /* @__PURE__ */ new Set();
+	for (const [rawName, value] of Object.entries(doc)) {
+		const name = rawName.trim();
+		const id = termId(name);
+		if (!id) {
+			warnings.push(`${where}: "${rawName}" has no letters or digits to make an id from`);
+			continue;
+		}
+		if (ids.has(id)) {
+			warnings.push(`${where}: "${name}" repeats an earlier term (id "${id}"); the first one wins`);
+			continue;
+		}
+		const v = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+		const def = text(typeof value === "object" ? v.def : value);
+		if (!def) {
+			warnings.push(`${where}: "${name}" has no definition`);
+			continue;
+		}
+		const more = text(v.more);
+		const href = text(typeof v.link === "object" && v.link ? v.link.href : v.link);
+		const label = typeof v.link === "object" && v.link ? text(v.link.label) : null;
+		ids.add(id);
+		pendingSee.set(id, list(v.see));
+		entries.push({
+			id,
+			name,
+			full: text(v.full),
+			aliases: list(v.aliases),
+			tag: text(v.tag),
+			link: href ? {
+				href,
+				label: label ?? linkLabel(href)
+			} : null,
+			see: [],
+			auto: v.auto !== false,
+			html: {
+				def: inlineHtml(def, math),
+				more: more ? inlineHtml(more, math) : null
+			}
+		});
+	}
+	const byWord = /* @__PURE__ */ new Map();
+	for (const e of entries) for (const w of [
+		e.name,
+		...e.aliases,
+		e.id
+	]) {
+		const key = w.toLowerCase();
+		const owner = byWord.get(key);
+		if (owner && owner !== e.id && w !== e.id) warnings.push(`${where}: "${w}" names both "${owner}" and "${e.id}"; the first one wins`);
+		else if (!owner) byWord.set(key, e.id);
+	}
+	for (const e of entries) for (const ref of pendingSee.get(e.id) ?? []) {
+		const target = byWord.get(ref.toLowerCase()) ?? byWord.get(termId(ref));
+		if (!target) warnings.push(`${where}: "${e.name}" says see "${ref}", which is not a term`);
+		else if (target !== e.id && !e.see.includes(target)) e.see.push(target);
+	}
+	return {
+		entries,
+		warnings
+	};
+}
+//#endregion
+export { parseGlossary };