@kadal/deck 0.0.0-stage → 0.1.0

package/dist/compiler/code-meta.js

@@ -0,0 +1,81 @@
+//#region src/compiler/code-meta.ts
+function parseLineSet(spec, total) {
+	const s = spec.trim();
+	if (s === "" || s === "all" || s === "*") return null;
+	if (s === "none" || s === "hide") return /* @__PURE__ */ new Set();
+	const out = /* @__PURE__ */ new Set();
+	for (const part of s.split(",")) {
+		const p = part.trim();
+		if (!p) continue;
+		const range = /^(\d+)\s*-\s*(\d+)?$/.exec(p);
+		if (range) {
+			const a = Number(range[1]);
+			const b = range[2] ? Number(range[2]) : total ?? a;
+			for (let i = Math.min(a, b); i <= Math.max(a, b); i++) out.add(i);
+			continue;
+		}
+		const n = Number(p);
+		if (Number.isFinite(n)) out.add(n);
+	}
+	return out;
+}
+function parseOptions(text, into) {
+	for (const pair of text.split(",")) {
+		const m = /^\s*([\w-]+)\s*:\s*(.+?)\s*$/.exec(pair);
+		if (!m) continue;
+		const key = m[1];
+		const raw = m[2].replace(/^['"]|['"]$/g, "");
+		if (key === "lines") into.lines = raw !== "false";
+		else if (key === "startLine") into.startLine = Number(raw) || 1;
+		else if (key === "maxHeight") into.maxHeight = raw;
+	}
+}
+function parseCodeMeta(meta) {
+	const out = {
+		steps: null,
+		lines: false,
+		startLine: 1,
+		title: null,
+		maxHeight: null,
+		hideUntilStep: false
+	};
+	if (!meta) return out;
+	let rest = meta.trim();
+	const reveal = /data-line-numbers(?:="([^"]*)")?/.exec(rest);
+	if (reveal) {
+		out.lines = true;
+		if (reveal[1]) out.steps = reveal[1].split("|").map((s) => parseLineSet(s));
+		rest = rest.replace(reveal[0], "");
+		const start = /data-ln-start-from="(\d+)"/.exec(rest);
+		if (start) out.startLine = Number(start[1]);
+	}
+	const title = /\[([^\]]+)\]/.exec(rest);
+	if (title) {
+		out.title = title[1].trim();
+		rest = rest.replace(title[0], "");
+	}
+	const braces = [...rest.matchAll(/\{([^}]*)\}/g)].map((m) => m[1]);
+	if (braces.length) {
+		const first = braces[0];
+		if (!/^\s*[\w-]+\s*:/.test(first)) {
+			const stages = first.split("|").map((s) => s.trim());
+			if (stages[0] === "hide") {
+				out.hideUntilStep = true;
+				stages.shift();
+			}
+			out.steps = stages.map((s) => parseLineSet(s));
+			if (out.steps.length === 0) out.steps = null;
+		} else parseOptions(first, out);
+		for (const extra of braces.slice(1)) parseOptions(extra, out);
+	}
+	return out;
+}
+/** Serialise steps for a `data-steps` attribute: `2,3|5|` (empty = all). */
+function serialiseSteps(steps) {
+	return steps.map((s) => s === null ? "*" : s.size === 0 ? "none" : [...s].sort((a, b) => a - b).join(",")).join("|");
+}
+function deserialiseSteps(text) {
+	return text.split("|").map((s) => parseLineSet(s));
+}
+//#endregion
+export { deserialiseSteps, parseCodeMeta, parseLineSet, serialiseSteps };

package/dist/compiler/index.d.ts

@@ -0,0 +1,8 @@
+import { Frontmatter, RawSlide, SplitOptions, SplitResult, levelOf, splitDeck, titleOf } from "./split.js";
+import { CodeMeta, LineSet, deserialiseSteps, parseCodeMeta, parseLineSet, serialiseSteps } from "./code-meta.js";
+import { MagicMoveBlock, MagicMoveStep, findMagicMoves } from "./magic-move.js";
+import { rehypeDeckCode } from "./rehype-code.js";
+import { RehypeGlossaryOptions, rehypeGlossary } from "./rehype-glossary.js";
+import { ParsedGlossary, parseGlossary } from "../glossary/parse.js";
+import { applySlots } from "./slots.js";
+export { type CodeMeta, type Frontmatter, type LineSet, type MagicMoveBlock, type MagicMoveStep, type ParsedGlossary, type RawSlide, type RehypeGlossaryOptions, type SplitOptions, type SplitResult, applySlots, deserialiseSteps, findMagicMoves, levelOf, parseCodeMeta, parseGlossary, parseLineSet, rehypeDeckCode, rehypeGlossary, serialiseSteps, splitDeck, titleOf };

package/dist/compiler/index.js

@@ -0,0 +1,8 @@
+import { deserialiseSteps, parseCodeMeta, parseLineSet, serialiseSteps } from "./code-meta.js";
+import { levelOf, splitDeck, titleOf } from "./split.js";
+import { findMagicMoves } from "./magic-move.js";
+import { rehypeDeckCode } from "./rehype-code.js";
+import { rehypeGlossary } from "./rehype-glossary.js";
+import { parseGlossary } from "../glossary/parse.js";
+import { applySlots } from "./slots.js";
+export { applySlots, deserialiseSteps, findMagicMoves, levelOf, parseCodeMeta, parseGlossary, parseLineSet, rehypeDeckCode, rehypeGlossary, serialiseSteps, splitDeck, titleOf };

package/dist/compiler/magic-move.d.ts

@@ -0,0 +1,26 @@
+//#region src/compiler/magic-move.d.ts
+/**
+ * Shiki Magic Move, the Slidev syntax: a Markdown fence of four backticks with the language `md`
+ * and the word `magic-move`, holding one code fence per step. The block morphs from step to step
+ * on each click, Keynote-style. We find the block in the raw slide text (before MDX sees it),
+ * precompute the keyed tokens for every step at build time with shiki-magic-move's core, and hand
+ * the slide a `<MagicMove steps={…} />` in its place — the runtime then animates without shipping
+ * a highlighter to the browser.
+ */
+export interface MagicMoveStep {
+  code: string;
+  lang: string;
+  /** The fence meta, e.g. `{1|2-3}{lines:true}` — highlight steps within this step. */
+  meta: string;
+}
+export interface MagicMoveBlock {
+  /** `{at:4, lines: true, duration: 500}`-style options on the outer fence. */
+  options: Record<string, string>;
+  title: string | null;
+  steps: MagicMoveStep[];
+}
+export declare function findMagicMoves(text: string): {
+  text: string;
+  blocks: MagicMoveBlock[];
+};
+//#endregion

package/dist/compiler/magic-move.js

@@ -0,0 +1,33 @@
+//#region src/compiler/magic-move.ts
+const OUTER = /^([ \t]*)````+\s*md\s+magic-move([^\n]*)\n([\s\S]*?)\n\1````+[ \t]*$/gm;
+const INNER = /```([\w+-]*)([^\n]*)\n([\s\S]*?)\n```/g;
+function findMagicMoves(text) {
+	const blocks = [];
+	return {
+		text: text.replace(OUTER, (_m, _indent, header, body) => {
+			const options = {};
+			const braces = /\{([^}]*)\}/.exec(header);
+			if (braces) for (const pair of braces[1].split(",")) {
+				const kv = /^\s*([\w-]+)\s*:\s*(.+?)\s*$/.exec(pair);
+				if (kv) options[kv[1]] = kv[2].replace(/^['"]|['"]$/g, "");
+			}
+			const title = /\[([^\]]+)\]/.exec(header);
+			const steps = [];
+			for (const m of body.matchAll(INNER)) steps.push({
+				lang: m[1] || "text",
+				meta: m[2].trim(),
+				code: m[3]
+			});
+			const id = blocks.length;
+			blocks.push({
+				options,
+				title: title ? title[1].trim() : null,
+				steps
+			});
+			return `\n<MagicMove block={${id}} />\n`;
+		}),
+		blocks
+	};
+}
+//#endregion
+export { findMagicMoves };

package/dist/compiler/plain-text.js

@@ -0,0 +1,7 @@
+//#region src/compiler/plain-text.ts
+/** A slide's MDX reduced to searchable text: no tags, no fence noise, no attribute braces. */
+function plainText(mdx) {
+	return mdx.replace(/```[^\n]*\n?/g, "").replace(/\{\/\*[\s\S]*?\*\/\}/g, "").replace(/<[^>]+>/g, " ").replace(/\{[^}]*\}/g, " ").replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[#*_`>~|]+/g, " ").replace(/\s+/g, " ").trim();
+}
+//#endregion
+export { plainText };

package/dist/compiler/rehype-code.d.ts

@@ -0,0 +1,18 @@
+import { Highlighter } from "shiki";
+import { Root } from "hast";
+//#region src/compiler/rehype-code.d.ts
+/**
+ * Turn every fenced code block into highlighted HTML at build time, and carry the fence meta over
+ * as data attributes the runtime `<Code>` reads: which lines light up on which click, whether to
+ * number lines, the title, the max height. Highlighting is Shiki with a light and a dark theme at
+ * once; the CSS picks by the deck's colour scheme.
+ */
+export interface RehypeCodeOptions {
+  highlighter: Highlighter;
+  themes: {
+    light: string;
+    dark: string;
+  };
+}
+export declare function rehypeDeckCode(options: RehypeCodeOptions): (tree: Root) => void;
+//#endregion

package/dist/compiler/rehype-code.js

@@ -0,0 +1,66 @@
+import { parseCodeMeta, serialiseSteps } from "./code-meta.js";
+import { visit } from "unist-util-visit";
+//#region src/compiler/rehype-code.ts
+function langOf(node) {
+	const cls = node.properties?.className;
+	const list = Array.isArray(cls) ? cls : typeof cls === "string" ? [cls] : [];
+	for (const c of list) {
+		const m = /^language-([\w+-]+)$/.exec(String(c));
+		if (m) return m[1];
+	}
+	return "text";
+}
+function textOf(node) {
+	let out = "";
+	const walk = (n) => {
+		if (n.type === "text") out += n.value;
+		for (const c of n.children ?? []) walk(c);
+	};
+	walk(node);
+	return out;
+}
+function rehypeDeckCode(options) {
+	const { highlighter, themes } = options;
+	return (tree) => {
+		visit(tree, "element", (node, index, parent) => {
+			if (node.tagName !== "pre" || !parent || index === void 0) return;
+			const code = node.children.find((c) => c.type === "element" && c.tagName === "code");
+			if (!code) return;
+			const lang = langOf(code);
+			if (lang === "math") return;
+			const meta = parseCodeMeta(code.data?.meta);
+			const source = textOf(code).replace(/\n$/, "");
+			const useLang = highlighter.getLoadedLanguages().includes(lang) ? lang : "text";
+			const pre = highlighter.codeToHast(source, {
+				lang: useLang,
+				themes,
+				defaultColor: false,
+				transformers: [{ line(el, line) {
+					el.properties["data-line"] = String(line + meta.startLine - 1);
+				} }]
+			}).children.find((c) => c.type === "element" && c.tagName === "pre");
+			if (!pre) return;
+			pre.properties = {
+				...pre.properties,
+				...dataAttributes(meta, lang, source.split("\n").length)
+			};
+			pre.properties.className = ["deck-code", "shiki"];
+			parent.children[index] = pre;
+		});
+	};
+}
+function dataAttributes(meta, lang, totalLines) {
+	const out = {
+		"data-lang": lang,
+		"data-total": String(totalLines)
+	};
+	if (meta.steps) out["data-steps"] = serialiseSteps(meta.steps);
+	if (meta.lines) out["data-lines"] = "true";
+	if (meta.startLine !== 1) out["data-start"] = String(meta.startLine);
+	if (meta.title) out["data-title"] = meta.title;
+	if (meta.maxHeight) out["data-max-height"] = meta.maxHeight;
+	if (meta.hideUntilStep) out["data-hide-until-step"] = "true";
+	return out;
+}
+//#endregion
+export { rehypeDeckCode };

package/dist/compiler/rehype-glossary.d.ts

@@ -0,0 +1,35 @@
+import { TermMatcher } from "../glossary/model.js";
+import { Root } from "hast";
+//#region src/compiler/rehype-glossary.d.ts
+/**
+ * Links a slide's key terms to the deck's glossary: each mention the matcher finds is wrapped in
+ * `<Term id auto>`, which shows the definition in a card after a short hover. The same idea as
+ * the pass that links Paadam's notes (apps/paadam/mdx/rehype-glossary.ts), retuned for slides:
+ *
+ *   · A slide is the unit. With `repeat: "first"` a term is linked once per slide — every slide
+ *     stands alone in front of an audience, nobody can scroll back to where it was first defined.
+ *   · Body text goes first and headings only pick up what the body never mentions (`headings:
+ *     "fallback"`): a slide whose title is its only mention of UTM still gets the link, but a
+ *     title is not underlined when the sentence below it can carry the term instead.
+ *   · Code, maths, links, controls and the components that animate or paint their own text
+ *     (GradientText, Typewriter, Counter…) are left alone; `className="no-terms"` opts a block out.
+ *
+ * Explicit `<Term>` elements are settled here as well, so the author hears about a typo at build
+ * time: `<Term>UTM</Term>` gets its `id`, `<Term def="…">` gets its definition rendered (with
+ * KaTeX, which the browser never has to load), and both count as the slide's mention of the term.
+ */
+export interface RehypeGlossaryOptions {
+  matcher: TermMatcher;
+  /** False settles the slide's explicit `<Term>`s and links nothing else (`terms: false`). */
+  auto?: boolean;
+  repeat: "first" | "all";
+  headings: "fallback" | boolean;
+  /** Extra component names to leave alone, from the headmatter. */
+  skip?: string[];
+  /** Term ids this slide does not link (`terms: { skip: [...] }` in its frontmatter). */
+  exclude?: Set<string>;
+  math?: (tex: string) => string;
+  warn?: (message: string) => void;
+}
+export declare function rehypeGlossary(options: RehypeGlossaryOptions): (tree: Root) => void;
+//#endregion

package/dist/compiler/rehype-glossary.js

@@ -0,0 +1,211 @@
+import { adhocId, inlineHtml } from "../glossary/model.js";
+//#region src/compiler/rehype-glossary.ts
+const HEADINGS = /* @__PURE__ */ new Set([
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]);
+const SKIP_TAGS = /* @__PURE__ */ new Set([
+	"code",
+	"pre",
+	"a",
+	"script",
+	"style",
+	"svg",
+	"math",
+	"kbd",
+	"abbr",
+	"button",
+	"select",
+	"option",
+	"textarea",
+	"iframe",
+	"video",
+	"audio"
+]);
+const SKIP_CLASSES = /* @__PURE__ */ new Set([
+	"no-terms",
+	"katex",
+	"math",
+	"math-inline",
+	"math-display"
+]);
+const SKIP_JSX = /* @__PURE__ */ new Set([
+	"Code",
+	"MagicMove",
+	"Tex",
+	"Math",
+	"Mermaid",
+	"Sketch",
+	"Notes",
+	"Link",
+	"Anchor",
+	"Toc",
+	"Image",
+	"Video",
+	"Audio",
+	"Iframe",
+	"Youtube",
+	"Tweet",
+	"Kbd",
+	"Counter",
+	"Typewriter",
+	"Encrypted",
+	"Timer",
+	"FitText",
+	"Qr",
+	"QrJoin",
+	"Background",
+	"GradientText",
+	"Shimmer",
+	"Icon",
+	"Poll",
+	"Quiz",
+	"Questions",
+	"Leaderboard",
+	"WordCloud",
+	"Presence",
+	"Reactions",
+	"Pace"
+]);
+const isJsx = (n) => n.type === "mdxJsxTextElement" || n.type === "mdxJsxFlowElement";
+function attr(el, name) {
+	return el.attributes.find((a) => a.type === "mdxJsxAttribute" && a.name === name);
+}
+const stringAttr = (el, name) => {
+	const v = attr(el, name)?.value;
+	return typeof v === "string" ? v : null;
+};
+function setAttr(el, name, value) {
+	const existing = attr(el, name);
+	if (existing) existing.value = value;
+	else el.attributes.push({
+		type: "mdxJsxAttribute",
+		name,
+		value
+	});
+}
+function classesOf(node) {
+	if (node.type === "element") {
+		const cls = node.properties?.className;
+		return Array.isArray(cls) ? cls.map(String) : typeof cls === "string" ? cls.split(/\s+/) : [];
+	}
+	if (isJsx(node)) return (stringAttr(node, "className") ?? stringAttr(node, "class") ?? "").split(/\s+/);
+	return [];
+}
+function textOf(node) {
+	if (node.type === "text") return node.value;
+	return (node.children ?? []).map(textOf).join("");
+}
+function rehypeGlossary(options) {
+	const { matcher, repeat, headings, exclude, math, warn } = options;
+	const skipJsx = /* @__PURE__ */ new Set([...SKIP_JSX, ...options.skip ?? []]);
+	return (tree) => {
+		const seen = new Set(exclude ?? []);
+		const jobs = [];
+		const settle = (el) => {
+			const def = stringAttr(el, "def");
+			if (def !== null) {
+				setAttr(el, "html", inlineHtml(def.replace(/\s+/g, " ").trim(), math));
+				const more = stringAttr(el, "more");
+				if (more !== null) setAttr(el, "moreHtml", inlineHtml(more.replace(/\s+/g, " ").trim(), math));
+				if (stringAttr(el, "id") === null) setAttr(el, "id", adhocId(`${textOf(el)}|${def}`));
+				return;
+			}
+			if (attr(el, "def")) return;
+			const wanted = stringAttr(el, "id") ?? textOf(el);
+			const entry = matcher.resolve(wanted);
+			if (!entry) {
+				warn?.(`<Term> "${wanted.trim()}" is not in the glossary and has no def`);
+				return;
+			}
+			setAttr(el, "id", entry.id);
+			seen.add(entry.id);
+		};
+		const collect = (node, heading) => {
+			let inHeading = heading;
+			if (node.type === "element") {
+				const tag = node.tagName;
+				if (SKIP_TAGS.has(tag)) return;
+				if (HEADINGS.has(tag)) inHeading = true;
+			} else if (isJsx(node)) {
+				if (node.name === "Term") return settle(node);
+				if (node.name && (skipJsx.has(node.name) || SKIP_TAGS.has(node.name))) return;
+				if (node.name && HEADINGS.has(node.name)) inHeading = true;
+			} else if (node.type !== "root") return;
+			if (classesOf(node).some((c) => SKIP_CLASSES.has(c))) return;
+			for (const child of node.children ?? []) if (child.type === "text") {
+				if (child.value.trim()) jobs.push({
+					node: child,
+					heading: inHeading
+				});
+			} else collect(child, inHeading);
+		};
+		collect(tree, false);
+		const replacements = /* @__PURE__ */ new Map();
+		const link = (job) => {
+			const src = job.node.value;
+			const out = [];
+			let last = 0;
+			for (const m of matcher.find(src)) {
+				if (exclude?.has(m.entry.id)) continue;
+				if (repeat === "first" && seen.has(m.entry.id)) continue;
+				seen.add(m.entry.id);
+				if (m.index > last) out.push({
+					type: "text",
+					value: src.slice(last, m.index)
+				});
+				out.push({
+					type: "mdxJsxTextElement",
+					name: "Term",
+					attributes: [{
+						type: "mdxJsxAttribute",
+						name: "id",
+						value: m.entry.id
+					}, {
+						type: "mdxJsxAttribute",
+						name: "auto",
+						value: null
+					}],
+					children: [{
+						type: "text",
+						value: m.text
+					}]
+				});
+				last = m.index + m.text.length;
+			}
+			if (!out.length) return;
+			if (last < src.length) out.push({
+				type: "text",
+				value: src.slice(last)
+			});
+			replacements.set(job.node, out);
+		};
+		if (options.auto === false) return;
+		if (headings === "fallback") {
+			jobs.filter((j) => !j.heading).forEach(link);
+			jobs.filter((j) => j.heading).forEach(link);
+		} else jobs.filter((j) => headings || !j.heading).forEach(link);
+		if (!replacements.size) return;
+		const rebuild = (node) => {
+			const kids = node.children;
+			if (!kids) return;
+			const next = [];
+			for (const child of kids) {
+				const swap = child.type === "text" ? replacements.get(child) : void 0;
+				if (swap) next.push(...swap);
+				else {
+					rebuild(child);
+					next.push(child);
+				}
+			}
+			node.children = next;
+		};
+		rebuild(tree);
+	};
+}
+//#endregion
+export { rehypeGlossary };

package/dist/compiler/slots.d.ts

@@ -0,0 +1,3 @@
+//#region src/compiler/slots.d.ts
+export declare function applySlots(body: string): string;
+//#endregion

package/dist/compiler/slots.js

@@ -0,0 +1,36 @@
+//#region src/compiler/slots.ts
+/**
+* Slidev's named slots for layouts: a line `::right::` (or any `::name::`) splits the slide body
+* into slots. Each slot becomes a `<div data-slot="name">` so a layout's CSS can place it — the
+* two-cols layout puts `default` in the left column and `right` in the right one. A body with no
+* markers is left untouched, so plain slides pay nothing for this.
+*/
+const MARKER = /^::([a-z][\w-]*)::[ \t]*$/;
+function applySlots(body) {
+	const lines = body.split("\n");
+	if (!lines.some((l) => MARKER.test(l))) return body;
+	const slots = [{
+		name: "default",
+		lines: []
+	}];
+	let fence = null;
+	for (const line of lines) {
+		const f = line.match(/^\s*(`{3,}|~{3,})/);
+		if (f) {
+			if (!fence) fence = f[1];
+			else if (line.trim().startsWith(fence[0]) && line.trim().length >= fence.length) fence = null;
+		}
+		const m = !fence && line.match(MARKER);
+		if (m) {
+			slots.push({
+				name: m[1],
+				lines: []
+			});
+			continue;
+		}
+		slots[slots.length - 1].lines.push(line);
+	}
+	return slots.filter((s) => s.lines.join("\n").trim()).map((s) => `<div data-slot="${s.name}" className="deck-slot deck-slot-${s.name}">\n\n${s.lines.join("\n").trim()}\n\n</div>`).join("\n\n");
+}
+//#endregion
+export { applySlots };

package/dist/compiler/split.d.ts

@@ -0,0 +1,63 @@
+//#region src/compiler/split.d.ts
+/**
+ * ─────────────────────────────────────────────────────────────────────────────
+ * THE DECK FILE
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * A deck is one MDX file, `deck.mdx`, read the way Slidev reads its Markdown and reveal.js reads
+ * its external Markdown — as text first, slides second:
+ *
+ *   ---            a line of three dashes starts the next slide (horizontal)
+ *   ----           a line of four or more dashes starts a slide BENEATH the previous one
+ *                  (a vertical stack, the reveal.js idea: a deep dive the audience may skip)
+ *   ---            the block right after a separator is that slide's FRONTMATTER when it is YAML
+ *   key: value     and closes with another line of three dashes; a fenced block at the very top
+ *   ---            of the file is the HEADMATTER, which configures the whole deck
+ *   <Notes>…</Notes>   anywhere in a slide: speaker notes, compiled as MDX of their own
+ *   src: ./file.mdx    a frontmatter-only slide that pulls the slides of another file in
+ *
+ * Everything in between is MDX: Markdown, JSX, the engine's components. This module only cuts
+ * the text; the Vite plugin turns the pieces into modules.
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+export type Frontmatter = Record<string, unknown>;
+export interface RawSlide {
+  /** Flat index in authored order, 0-based. */
+  index: number;
+  /** Horizontal column and vertical position in it. */
+  h: number;
+  v: number;
+  frontmatter: Frontmatter;
+  /** The slide's MDX with notes and frontmatter removed. */
+  content: string;
+  /** The notes' MDX, or null when the slide has none. */
+  notes: string | null;
+  /** Where the slide starts, for error messages and the editor. */
+  source: {
+    file: string;
+    line: number;
+  };
+}
+export interface SplitResult {
+  headmatter: Frontmatter;
+  slides: RawSlide[];
+}
+export interface SplitOptions {
+  file: string;
+  /** Returns the text of an included file (the `src:` frontmatter), or null when it is missing. */
+  resolveInclude?: (path: string, from: string) => {
+    file: string;
+    text: string;
+  } | null;
+}
+/**
+ * Split a deck file into slides. Includes (`src:`) are expanded in place; a piece that is only
+ * frontmatter with a `src` contributes the included file's slides, with the included file's own
+ * headmatter and the piece's remaining frontmatter merged into the first of them.
+ */
+export declare function splitDeck(text: string, options: SplitOptions): SplitResult;
+/** The title a slide reports to the table of contents: frontmatter `title`, else its first heading. */
+export declare function titleOf(slide: Pick<RawSlide, "content" | "frontmatter">): string | null;
+/** The level of the title, for the table of contents: frontmatter `level`, else the heading depth. */
+export declare function levelOf(slide: Pick<RawSlide, "content" | "frontmatter">): number;
+//#endregion