gutterpress 0.11.21 → 0.11.22-alpha.1

package/dist/cli-pfrg1r9x.js

@@ -0,0 +1,3073 @@
+import {
+  PACKAGE_VERSION,
+  debug
+} from "./cli-5553w972.js";
+import {
+  isExactNpmVersion,
+  isValidNpmPackageName,
+  packageResolutionTargets,
+  resolvePackageEntry,
+  resolveVendoredPluginInstallRoot,
+  safePackageTarget,
+  vendoredNpmPluginPackageDir
+} from "./cli-h3phdstf.js";
+
+// src/lib/markdown/plugins.ts
+import { existsSync as existsSync2, readFileSync, statSync, unlinkSync } from "node:fs";
+import { link, unlink } from "node:fs/promises";
+import { isBuiltin } from "node:module";
+import { resolve as resolve2, join, dirname, basename, extname, isAbsolute, relative, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/lib/style-declarations.ts
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+function resolveDeclaredStyles(rawStyles, baseDir, subject) {
+  if (!rawStyles || rawStyles.length === 0)
+    return;
+  return rawStyles.map((rel) => {
+    const abs = resolve(baseDir, rel);
+    if (!existsSync(abs)) {
+      throw new Error(`${subject} declares stylesheet "${rel}" but no file exists at ${abs}.`);
+    }
+    return abs;
+  });
+}
+
+// src/lib/extension-manifest.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { satisfies, validRange } from "semver";
+var EXTENSION_MANIFEST_FILENAME = "package.json";
+var GUTTERPRESS_KEY = "gutterpress";
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function str(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function authorName(value) {
+  return str(value) ?? str(object(value)?.name);
+}
+function metaFromPackageJson(raw) {
+  const pkg = object(raw);
+  if (!pkg)
+    return {};
+  const gp = object(pkg[GUTTERPRESS_KEY]) ?? {};
+  const keywords = Array.isArray(pkg.keywords) ? pkg.keywords.filter((k) => typeof k === "string") : undefined;
+  return {
+    ...str(pkg.name) ? { name: str(pkg.name) } : {},
+    ...authorName(pkg.author) ? { author: authorName(pkg.author) } : {},
+    ...str(pkg.description) ? { description: str(pkg.description) } : {},
+    ...keywords ? { keywords } : {},
+    ...str(pkg.main) ? { main: str(pkg.main) } : {},
+    ...str(object(pkg.engines)?.gutterpress) ? { gutterpressRange: str(object(pkg.engines)?.gutterpress) } : {},
+    ..."preview" in gp ? { preview: str(gp.preview) ?? null } : {},
+    ...Array.isArray(gp.styles) ? { styles: declaredList(gp.styles) } : {},
+    ...str(gp.tokensFile) ? { tokensFile: str(gp.tokensFile) } : {},
+    ...str(gp.markdown) ? { markdown: str(gp.markdown) } : {},
+    ...str(gp.components) ? { components: str(gp.components) } : {},
+    ...str(gp.snippets) ? { snippets: str(gp.snippets) } : {},
+    ...gp.publish === true ? { publish: true } : {},
+    ...gp.engineStyles !== undefined ? { engineStyles: gp.engineStyles } : {}
+  };
+}
+async function readExtensionMeta(dir) {
+  try {
+    return metaFromPackageJson(JSON.parse(await readFile(path.join(dir, EXTENSION_MANIFEST_FILENAME), "utf8")));
+  } catch {
+    return {};
+  }
+}
+function declaredList(value) {
+  return Array.isArray(value) ? value.filter((s) => typeof s === "string" && s.trim().length > 0) : [];
+}
+function extensionStyleList(meta) {
+  return declaredList(meta.styles);
+}
+function extensionEntry(meta) {
+  return meta.markdown?.trim() || (meta.publish ? undefined : meta.main?.trim()) || undefined;
+}
+function extensionCarries(meta) {
+  return {
+    markdown: !!extensionEntry(meta),
+    styles: extensionStyleList(meta).length > 0,
+    snippets: !!meta.snippets?.trim(),
+    components: !!meta.components?.trim(),
+    publish: meta.publish === true
+  };
+}
+function assertPublishOnly(meta, ref) {
+  if (!meta.publish)
+    return;
+  const carries = extensionCarries(meta);
+  const also = ["markdown", "styles", "components", "snippets"].filter((k) => carries[k]);
+  if (also.length > 0) {
+    throw new Error(`Publishing plugin "${ref}" also declares ${also.join(", ")} — a package is a ` + "publisher or a markdown plugin, not both.");
+  }
+}
+function pathEscapesFolder(rel) {
+  return path.isAbsolute(rel) || rel.split(/[\\/]/).includes("..");
+}
+function assertSupportsThisGutterpress(meta, ref) {
+  const range = meta.gutterpressRange;
+  if (range === undefined)
+    return;
+  if (!validRange(range)) {
+    throw new Error(`Extension "${ref}" has an invalid engines.gutterpress range "${range}".`);
+  }
+  if (!satisfies(PACKAGE_VERSION, range, { includePrerelease: true })) {
+    throw new Error(`Extension "${ref}" needs Gutterpress ${range} (its package.json engines.gutterpress); ` + `this is Gutterpress ${PACKAGE_VERSION}. Update Gutterpress, or pin an older version of the extension.`);
+  }
+}
+function assertExtensionContained(meta) {
+  if (meta.engineStyles !== undefined) {
+    throw new Error("The extension's metadata declares `engineStyles`, which was removed — " + "move its entries to the end of `styles`.");
+  }
+  const entry = extensionEntry(meta);
+  const declared = [
+    ...extensionStyleList(meta),
+    ...entry ? [entry] : [],
+    ...meta.publish && meta.main?.trim() ? [meta.main.trim()] : [],
+    ...meta.components ? [meta.components] : [],
+    ...meta.snippets ? [meta.snippets] : [],
+    ...meta.tokensFile ? [meta.tokensFile] : []
+  ];
+  for (const rel of declared) {
+    if (pathEscapesFolder(rel)) {
+      throw new Error(`Extension metadata declares "${rel}" outside its own folder; an extension must be self-contained.`);
+    }
+  }
+}
+function resolveExtension(dir, meta, subject) {
+  const entry = extensionEntry(meta);
+  const styles = resolveDeclaredStyles(extensionStyleList(meta), dir, subject);
+  const [markdown] = resolveDeclaredStyles(entry ? [entry] : undefined, dir, subject) ?? [];
+  const [components] = resolveDeclaredStyles(meta.components ? [meta.components] : undefined, dir, subject) ?? [];
+  const [snippets] = resolveDeclaredStyles(meta.snippets ? [meta.snippets] : undefined, dir, subject) ?? [];
+  return {
+    ...markdown ? { markdown } : {},
+    ...styles ? { styles } : {},
+    ...meta.tokensFile?.trim() ? { tokensFile: meta.tokensFile.trim() } : {},
+    ...components ? { components } : {},
+    ...snippets ? { snippets } : {}
+  };
+}
+
+// src/lib/markdown/renderer.ts
+import MarkdownIt from "markdown-it";
+import markdownItAttrs from "markdown-it-attrs";
+import markdownItFootnote from "markdown-it-footnote";
+
+// src/lib/markdown/markers.js
+function unwrapAttrBraces(token) {
+  if (typeof token !== "string")
+    return token;
+  let t = token.trim();
+  if (t.startsWith("{"))
+    t = t.slice(1).trim();
+  if (t.endsWith("}"))
+    t = t.slice(0, -1).trim();
+  return t || token;
+}
+function isBareToken(token) {
+  return token && !token.includes("=") && !token.startsWith(".") && !token.startsWith("#");
+}
+var KNOWN_KINDS = [
+  "chapter",
+  "spread",
+  "page",
+  "section",
+  "continue",
+  "page-break",
+  "column-break",
+  "end-section"
+];
+var BARE_TOKEN_RE = /^[A-Za-z0-9_][A-Za-z0-9_.:-]*$/;
+function editDistance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1;i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1;j <= b.length; j++) {
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+    prev = cur;
+  }
+  return prev[b.length];
+}
+function nearestKind(word) {
+  const w = word.toLowerCase();
+  if (w.length < 3)
+    return null;
+  for (const kind of KNOWN_KINDS) {
+    if (editDistance(w, kind) <= 1)
+      return kind;
+  }
+  return null;
+}
+function escapeHtml(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function parseMarkerLine(line, declaredWords) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("@"))
+    return null;
+  const tokens = [];
+  let buf = "";
+  let quote = null;
+  for (let i = 0;i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (quote) {
+      if (ch === quote)
+        quote = null;
+      else
+        buf += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (buf)
+        tokens.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf)
+    tokens.push(buf);
+  for (let i = 1;i < tokens.length; i++)
+    tokens[i] = unwrapAttrBraces(tokens[i]);
+  const head = tokens[0];
+  const kind = head.slice(1);
+  if (!KNOWN_KINDS.includes(kind) && !(declaredWords && declaredWords.has(kind)))
+    return null;
+  if (kind === "continue" || kind.startsWith("end-")) {
+    return { kind, name: null, attrs: {} };
+  }
+  const isBreak = kind === "page-break" || kind === "column-break";
+  const body = isBreak ? tokens.slice(1).filter((token) => !isBareToken(token)) : tokens.slice(1);
+  const hasExplicitAttrsOrShorthand = body.some((token) => token.includes("=") || token.startsWith(".") || token.startsWith("#"));
+  const bareTokens = body.filter(isBareToken);
+  let name = null;
+  let nameIndex = -1;
+  const firstBareTokenIndex = body.findIndex((token) => isBareToken(token));
+  if (hasExplicitAttrsOrShorthand && bareTokens.length) {
+    name = bareTokens[0];
+    nameIndex = firstBareTokenIndex;
+  } else if (bareTokens.length === 1) {
+    name = bareTokens[0];
+    nameIndex = firstBareTokenIndex;
+  }
+  const attrs = {};
+  const classes = [];
+  let sawExplicitAttr = false;
+  let hasAmbiguousBareToken = false;
+  const unknownTokens = [];
+  for (const t of body) {
+    if (t.startsWith(".") || t.startsWith("#")) {
+      if (!BARE_TOKEN_RE.test(t.slice(1).trim()))
+        unknownTokens.push(t);
+      continue;
+    }
+    if (t.indexOf("=") > 0)
+      continue;
+    if (!BARE_TOKEN_RE.test(t))
+      unknownTokens.push(t);
+  }
+  for (let idx = 0;idx < body.length; idx++) {
+    if (idx === nameIndex) {
+      if (sawExplicitAttr && isBareToken(body[idx]))
+        hasAmbiguousBareToken = true;
+      continue;
+    }
+    const t = body[idx];
+    if (t.startsWith(".")) {
+      const c = t.slice(1).trim();
+      if (c)
+        classes.push(c);
+      continue;
+    }
+    if (t.startsWith("#")) {
+      const id = t.slice(1).trim();
+      if (id)
+        attrs.id = id;
+      continue;
+    }
+    const eq = t.indexOf("=");
+    if (eq > 0) {
+      sawExplicitAttr = true;
+      const key = t.slice(0, eq).trim();
+      const val = t.slice(eq + 1).trim();
+      if (!key)
+        continue;
+      if (key === "class") {
+        val.split(/[,\s]+/).filter(Boolean).forEach((c) => classes.push(c));
+      } else {
+        attrs[key] = val;
+      }
+      continue;
+    }
+    if (sawExplicitAttr && isBareToken(t))
+      hasAmbiguousBareToken = true;
+    classes.push(t);
+  }
+  if (classes.length)
+    attrs.class = classes.join(" ");
+  if (isBreak)
+    return { kind, name: null, attrs };
+  const marker = { kind, name, attrs };
+  if (hasAmbiguousBareToken)
+    marker.__ambiguousBareToken = true;
+  if (unknownTokens.length)
+    marker.__unknownTokens = unknownTokens;
+  if (bareTokens.length > 1 && !hasAmbiguousBareToken && !unknownTokens.length) {
+    marker.__extraBareTokens = { tokens: bareTokens, named: name !== null };
+  }
+  return marker;
+}
+function warn(env, line, type, message, marker) {
+  if (!env.layoutWarnings)
+    env.layoutWarnings = [];
+  env.layoutWarnings.push({ line, type, message, marker });
+}
+var COMPONENT_SEVERITIES = ["error", "warning", "info"];
+function blockEnd(tokens, i) {
+  if (tokens[i].nesting !== 1)
+    return i;
+  let depth = 0;
+  for (let j = i;j < tokens.length; j++) {
+    depth += tokens[j].nesting;
+    if (depth === 0)
+      return j;
+  }
+  return tokens.length - 1;
+}
+function inlineText(tokens, from, to) {
+  const parts = [];
+  for (let k = from;k <= to; k++)
+    if (tokens[k].type === "inline")
+      parts.push(tokens[k].content);
+  return parts.join(`
+`);
+}
+function soleImage(inline) {
+  const parts = (inline && inline.children || []).filter((c) => c.type !== "softbreak" && !(c.type === "text" && !c.content.trim()));
+  return parts.length === 1 && parts[0].type === "image" ? parts[0] : null;
+}
+function toComponentBlocks(tokens, fallbackLine) {
+  const blocks = [];
+  for (let i = 0;i < tokens.length; i++) {
+    const tok = tokens[i];
+    const end = blockEnd(tokens, i);
+    const line = tok.map ? tok.map[0] + 1 : tok.meta && tok.meta.line || fallbackLine;
+    switch (tok.type) {
+      case "heading_open":
+        blocks.push({ type: "heading", level: Number(tok.tag.slice(1)), text: inlineText(tokens, i, end), line });
+        break;
+      case "paragraph_open": {
+        const image = soleImage(tokens[i + 1]);
+        blocks.push(image ? { type: "image", alt: image.content, src: image.attrGet("src") || "", line } : { type: "paragraph", text: inlineText(tokens, i, end), line });
+        break;
+      }
+      case "bullet_list_open":
+      case "ordered_list_open": {
+        const items = [];
+        for (let k = i + 1;k < end; k++) {
+          if (tokens[k].type !== "list_item_open" || tokens[k].level !== tok.level + 1)
+            continue;
+          const itemEnd = blockEnd(tokens, k);
+          const first = tokens.slice(k + 1, itemEnd).find((t) => t.type === "inline");
+          items.push(first ? first.content : "");
+          k = itemEnd;
+        }
+        blocks.push({ type: "list", ordered: tok.type === "ordered_list_open", items, line });
+        break;
+      }
+      case "blockquote_open":
+        blocks.push({ type: "quote", text: inlineText(tokens, i, end), line });
+        break;
+      case "fence":
+      case "code_block":
+        blocks.push({ type: "code", lang: (tok.info || "").trim().split(/\s+/)[0] || "", text: tok.content, line });
+        break;
+      case "table_open":
+        blocks.push({ type: "table", line });
+        break;
+      case "hr":
+        blocks.push({ type: "rule", line });
+        break;
+      case "html_block":
+        blocks.push({ type: "html", text: tok.content, line });
+        break;
+      case "layout_component_open":
+        blocks.push({ type: "component", name: tok.meta.component, line });
+        break;
+      default:
+        blocks.push({ type: tok.type.replace(/_open$/, ""), line });
+    }
+    i = end;
+  }
+  return blocks;
+}
+function runComponentValidate(env, decl, meta, tokens, lines) {
+  const name = meta.component;
+  const line = meta.line || 0;
+  const report = (at, type, message, severity) => {
+    if (!env.layoutWarnings)
+      env.layoutWarnings = [];
+    env.layoutWarnings.push(severity ? { line: at, type, message, severity } : { line: at, type, message });
+  };
+  const failed = (why) => report(line, "component_validate_failed", `@${name}: plugin "${decl.validateOwner}"'s validate() ${why}`);
+  let lastLine = line;
+  for (const t of tokens)
+    if (t.map && t.map[1] > lastLine)
+      lastLine = t.map[1];
+  const component = {
+    name,
+    variant: meta.variant || null,
+    attrs: { ...meta.attrs },
+    line,
+    text: lines.slice(line, lastLine).join(`
+`),
+    blocks: toComponentBlocks(tokens, line)
+  };
+  let result;
+  try {
+    result = decl.validate(component);
+  } catch (error) {
+    failed(`threw: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  if (result === undefined || result === null)
+    return;
+  if (typeof result === "string")
+    result = [result];
+  if (!Array.isArray(result)) {
+    failed("must return a message, an array of problems, or nothing (and must not be async).");
+    return;
+  }
+  for (const entry of result) {
+    const problem = typeof entry === "string" ? { message: entry } : entry;
+    if (!problem || typeof problem.message !== "string" || !problem.message.trim()) {
+      failed("returned a problem without a message.");
+      continue;
+    }
+    const at = Number.isInteger(problem.line) && problem.line > 0 ? problem.line : line;
+    const severity = COMPONENT_SEVERITIES.includes(problem.severity) ? problem.severity : undefined;
+    report(at, "component_invalid", `@${name}: ${problem.message}`, severity);
+  }
+}
+function proseEscapeHint(kind) {
+  return ` If this line is prose that happens to begin with "@${kind}" — a wrapped sentence, for` + ` instance — escape it as \\@${kind} or write it as \`@${kind}\` in backticks, and it stays text.`;
+}
+function addClasses(token, baseClass, extraClass) {
+  const cls = [];
+  if (baseClass)
+    cls.push(baseClass);
+  if (extraClass)
+    cls.push(extraClass);
+  const merged = cls.join(" ").trim();
+  if (merged)
+    token.attrSet("class", merged);
+}
+function attachDataAttrs(token, kind, name, attrs) {
+  if (name) {
+    if (kind === "chapter")
+      token.attrSet("data-chapter-label", name);
+    else if (kind === "spread")
+      token.attrSet("data-spread", name);
+    else if (kind === "page")
+      token.attrSet("data-page", name);
+    else if (kind === "section")
+      token.attrSet("data-section", name);
+    else
+      token.attrSet(`data-${kind}`, name);
+  }
+  if (attrs.template)
+    token.attrSet("data-template", attrs.template);
+  if (attrs.region)
+    token.attrSet("data-region", attrs.region);
+  if (attrs.id)
+    token.attrSet("id", attrs.id);
+  for (const [k, v] of Object.entries(attrs)) {
+    if (!v)
+      continue;
+    if (k === "class" || k === "id" || k === "template" || k === "region")
+      continue;
+    token.attrSet(k.startsWith("data-") ? k : `data-${k}`, v);
+  }
+}
+function attachBreak(token, baseClass, attrs = {}) {
+  addClasses(token, baseClass, attrs.class);
+  token.attrSet("aria-hidden", "true");
+  attachDataAttrs(token, "break", null, attrs);
+}
+var DECLARED_NAME_RE = /^[a-z][a-z0-9-]*$/;
+function validateDeclaredMarkerName(name, pluginName) {
+  if (!DECLARED_NAME_RE.test(name)) {
+    throw new Error(`Plugin "${pluginName}" declares marker "@${name}" with an invalid name — marker names must be ` + `lower-case letters, digits and hyphens, starting with a letter (like core's own "page-break").`);
+  }
+  if (name.startsWith("end-")) {
+    throw new Error(`Plugin "${pluginName}" declares marker "@${name}", but names starting with "end-" are reserved ` + `for the auto-derived closer of another declared marker (a container named "${name.slice(4)}" ` + `would collide with it). Rename this marker.`);
+  }
+}
+var TAG_NAME_RE = /^[a-z][a-z0-9-]*$/;
+function resolveContainerShape(name, pluginName, decl) {
+  if (decl.section !== undefined && typeof decl.section !== "boolean") {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`section\` that is not a boolean.`);
+  }
+  if (decl.section) {
+    for (const field of ["tag", "label", "autoCloseAt", "selfClosing"]) {
+      if (decl[field] !== undefined) {
+        throw new Error(`Plugin "${pluginName}"'s marker "@${name}" sets \`section: true\` and \`${field}\` — a section ` + `marker is a core @section, so \`${field}\` does not apply. Remove one of them.`);
+      }
+    }
+  }
+  const tag = decl.tag !== undefined ? decl.tag : "div";
+  if (typeof tag !== "string" || !TAG_NAME_RE.test(tag)) {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has an invalid \`tag\` (${JSON.stringify(decl.tag)}) — ` + `must be a lower-case HTML tag name.`);
+  }
+  const classBase = decl.class !== undefined ? decl.class : "";
+  if (typeof classBase !== "string") {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`class\` that is not a string.`);
+  }
+  let variants;
+  if (decl.variants !== undefined) {
+    if (typeof decl.variants !== "object" || decl.variants === null || Array.isArray(decl.variants)) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has \`variants\` that is not a plain object.`);
+    }
+    variants = {};
+    for (const [variantName, variantClass] of Object.entries(decl.variants)) {
+      if (typeof variantClass !== "string") {
+        throw new Error(`Plugin "${pluginName}"'s marker "@${name}" variant "${variantName}" is not a string.`);
+      }
+      variants[variantName] = variantClass;
+    }
+  }
+  let label;
+  if (decl.label !== undefined) {
+    if (typeof decl.label !== "object" || decl.label === null || Array.isArray(decl.label)) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`label\` that is not an object.`);
+    }
+    if (typeof decl.label.class !== "string" || !decl.label.class) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`label.class\` that is not a non-empty string.`);
+    }
+    const match = typeof decl.label.from === "string" ? /^attr:([A-Za-z_][A-Za-z0-9_-]*)$/.exec(decl.label.from) : null;
+    if (!match) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`label.from\` (${JSON.stringify(decl.label.from)}) that is not "attr:<name>" — that is the only supported form today.`);
+    }
+    const labelTag = decl.label.tag !== undefined ? decl.label.tag : "div";
+    if (typeof labelTag !== "string" || !TAG_NAME_RE.test(labelTag)) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has an invalid \`label.tag\` (${JSON.stringify(decl.label.tag)}).`);
+    }
+    label = { class: decl.label.class, attr: match[1], tag: labelTag };
+  }
+  let autoCloseAtEof = false;
+  if (decl.autoCloseAt !== undefined) {
+    if (!Array.isArray(decl.autoCloseAt)) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has an \`autoCloseAt\` that is not an array.`);
+    }
+    for (const value of decl.autoCloseAt) {
+      if (value !== "eof") {
+        throw new Error(`Plugin "${pluginName}"'s marker "@${name}" declares an unsupported \`autoCloseAt\` value ` + `${JSON.stringify(value)} — only "eof" is currently supported.`);
+      }
+    }
+    autoCloseAtEof = decl.autoCloseAt.includes("eof");
+  }
+  if (decl.selfClosing !== undefined && typeof decl.selfClosing !== "boolean") {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`selfClosing\` that is not a boolean.`);
+  }
+  if (decl.selfClosing && decl.autoCloseAt !== undefined) {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" sets \`selfClosing: true\` and \`autoCloseAt\` — a ` + `self-closing marker has no open container to auto-close. Remove one of them.`);
+  }
+  if (decl.validate !== undefined && typeof decl.validate !== "function") {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`validate\` that is not a function.`);
+  }
+  const check = decl.validate ? { validate: decl.validate, validateOwner: pluginName } : {};
+  return {
+    tag,
+    classBase,
+    variants,
+    label,
+    autoCloseAtEof,
+    ...decl.section ? { section: true } : {},
+    ...decl.selfClosing ? { selfClosing: true } : {},
+    ...check
+  };
+}
+function presetVariantOf(name, pluginName, rawDecl) {
+  const preset = rawDecl.preset !== undefined ? rawDecl.preset : {};
+  if (typeof preset !== "object" || preset === null || Array.isArray(preset)) {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`preset\` that is not a plain object.`);
+  }
+  if (preset.variant !== undefined && typeof preset.variant !== "string") {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`preset.variant\` that is not a string.`);
+  }
+  return preset.variant;
+}
+function resolveMarkerDeclaration(name, rawDecl, rawRegistry, originOf) {
+  const pluginName = originOf.get(name);
+  if (typeof rawDecl !== "object" || rawDecl === null || Array.isArray(rawDecl)) {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" is not a plain object.`);
+  }
+  if (rawDecl.snippet !== undefined && (typeof rawDecl.snippet !== "string" || !rawDecl.snippet.trim())) {
+    throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`snippet\` that is not a non-empty path string.`);
+  }
+  if (rawDecl.deprecated !== undefined) {
+    if (typeof rawDecl.deprecated !== "string" || !rawDecl.deprecated) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has a \`deprecated\` value that is not a non-empty string.`);
+    }
+    return { name, deprecated: rawDecl.deprecated };
+  }
+  if (rawDecl.alias !== undefined) {
+    if (typeof rawDecl.alias !== "string" || !rawDecl.alias) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" has an \`alias\` value that is not a non-empty string.`);
+    }
+    const targetRaw = rawRegistry.get(rawDecl.alias);
+    if (!targetRaw) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" aliases unknown marker "@${rawDecl.alias}" — no ` + `loaded plugin declares it.`);
+    }
+    if (targetRaw.deprecated !== undefined) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" aliases "@${rawDecl.alias}", which is deprecated: ` + `${targetRaw.deprecated}`);
+    }
+    if (targetRaw.alias !== undefined) {
+      throw new Error(`Plugin "${pluginName}"'s marker "@${name}" aliases "@${rawDecl.alias}", which is itself an alias. ` + `Chained aliases are not supported — alias the base marker directly.`);
+    }
+    const container = resolveContainerShape(rawDecl.alias, originOf.get(rawDecl.alias), targetRaw);
+    return { name, baseKind: rawDecl.alias, presetVariant: presetVariantOf(name, pluginName, rawDecl), ...container };
+  }
+  const presetVariant = presetVariantOf(name, pluginName, rawDecl);
+  return {
+    name,
+    baseKind: name,
+    ...presetVariant !== undefined ? { presetVariant } : {},
+    ...resolveContainerShape(name, pluginName, rawDecl)
+  };
+}
+var CORE_MARKER_OWNER = "Gutterpress";
+var CORE_DECLARED_MARKERS = {
+  columns: {
+    class: "gp-columns",
+    preset: { variant: "2" },
+    variants: { 1: "gp-columns-1", 2: "gp-columns-2", 3: "gp-columns-3", 4: "gp-columns-4", 5: "gp-columns-5" }
+  },
+  page: { variants: { blank: "gp-page-blank", "full-bleed": "gp-page-full-bleed" } }
+};
+var LOCATION_KINDS = ["page", "chapter", "section"];
+var LOCATION_KEYS = ["variants", "label", "snippet"];
+function isLocationDeclaration(name, rawDecl) {
+  return LOCATION_KINDS.includes(name) && rawDecl !== null && typeof rawDecl === "object" && !Array.isArray(rawDecl) && Object.hasOwn(rawDecl, "variants") && Object.keys(rawDecl).every((k) => LOCATION_KEYS.includes(k));
+}
+function addLocationVariants(kind, rawDecl, pluginName, into) {
+  const { variants, label, snippet } = rawDecl;
+  const where = `Plugin "${pluginName}" declares @${kind} variants`;
+  if (variants === null || typeof variants !== "object" || Array.isArray(variants)) {
+    throw new Error(`${where} that are not a plain object of { word: 'class' }.`);
+  }
+  if (label !== undefined && typeof label !== "string")
+    throw new Error(`${where} with a \`label\` that is not a string.`);
+  if (snippet !== undefined && typeof snippet !== "string")
+    throw new Error(`${where} with a \`snippet\` that is not a string.`);
+  for (const [word, cls] of Object.entries(variants)) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(word)) {
+      throw new Error(`${where} with an invalid word "${word}" — use letters, digits, hyphens and underscores.`);
+    }
+    if (typeof cls !== "string" || !cls.trim()) {
+      throw new Error(`${where}: variant "${word}" needs a non-empty class string.`);
+    }
+    const taken = into[kind].get(word);
+    if (taken) {
+      throw new Error(`@${kind} variant "${word}" is declared by both plugin "${taken.owner}" and plugin "${pluginName}". ` + `Variant words must be unique across every loaded plugin — rename one of them.`);
+    }
+    into[kind].set(word, { class: cls.trim(), owner: pluginName, ...label ? { label } : {}, ...snippet ? { snippet } : {} });
+  }
+}
+function buildDeclaredMarkerRegistry(sources) {
+  const rawRegistry = new Map;
+  const originOf = new Map;
+  const locationVariants = { page: new Map, chapter: new Map, section: new Map };
+  for (const { pluginName, markers } of [{ pluginName: CORE_MARKER_OWNER, markers: CORE_DECLARED_MARKERS }, ...sources]) {
+    if (!markers)
+      continue;
+    for (const [name, rawDecl] of Object.entries(markers)) {
+      validateDeclaredMarkerName(name, pluginName);
+      if (isLocationDeclaration(name, rawDecl)) {
+        addLocationVariants(name, rawDecl, pluginName, locationVariants);
+        continue;
+      }
+      if (KNOWN_KINDS.includes(name) || pluginName !== CORE_MARKER_OWNER && name in CORE_DECLARED_MARKERS) {
+        throw new Error(`Plugin "${pluginName}" declares marker "@${name}", which is a core Gutterpress marker name ` + `(${[...KNOWN_KINDS, ...Object.keys(CORE_DECLARED_MARKERS).filter((k) => !KNOWN_KINDS.includes(k))].map((k) => `@${k}`).join(", ")}). ` + `Core marker names cannot be shadowed — ` + `rename the plugin's marker.`);
+      }
+      if (rawRegistry.has(name)) {
+        throw new Error(`Marker "@${name}" is declared by both plugin "${originOf.get(name)}" and plugin "${pluginName}". ` + `Declared marker names must be unique across every loaded plugin — rename one of them.`);
+      }
+      rawRegistry.set(name, rawDecl);
+      originOf.set(name, pluginName);
+    }
+  }
+  const resolved = new Map;
+  for (const [name, rawDecl] of rawRegistry) {
+    resolved.set(name, resolveMarkerDeclaration(name, rawDecl, rawRegistry, originOf));
+  }
+  resolved.locationVariants = locationVariants;
+  return resolved;
+}
+function declaredKindWords(declaredMarkers) {
+  if (!declaredMarkers)
+    return null;
+  const words = new Set;
+  for (const name of declaredMarkers.keys()) {
+    words.add(name);
+    words.add(`end-${name}`);
+  }
+  return words;
+}
+function nearestDeclaredMarkerName(word, names) {
+  const w = word.toLowerCase();
+  const threshold = Math.max(2, Math.floor(w.length / 3));
+  let best = null;
+  let bestDistance = Infinity;
+  for (const known of names) {
+    const d = editDistance(w, known);
+    if (d < bestDistance) {
+      bestDistance = d;
+      best = known;
+    }
+  }
+  return best !== null && bestDistance > 0 && bestDistance <= threshold ? best : null;
+}
+function scanForUnknownDeclaredMarkers(state, declaredMarkers) {
+  if (!declaredMarkers)
+    return;
+  for (let tokenIndex = 0;tokenIndex < state.tokens.length; tokenIndex++) {
+    const tok = state.tokens[tokenIndex];
+    if (tok.type !== "inline" || !tok.map)
+      continue;
+    const opener = state.tokens[tokenIndex - 1];
+    if (!opener || opener.type !== "paragraph_open")
+      continue;
+    const lines = tok.content.split(`
+`);
+    for (let i = 0;i < lines.length; i++) {
+      const m = /^@([A-Za-z][A-Za-z0-9-]*)(?=\s|$)/.exec(lines[i].trim());
+      if (!m)
+        continue;
+      const word = m[1];
+      if (KNOWN_KINDS.includes(word) || declaredMarkers.has(word))
+        continue;
+      const suggestion = nearestDeclaredMarkerName(word, declaredMarkers.keys());
+      if (!suggestion)
+        continue;
+      warn(state.env, tok.map[0] + i + 1, "unknown_marker", `Unknown marker "@${word}". Did you mean "@${suggestion}"?`, null);
+    }
+  }
+}
+function variantClassFor(decl, word) {
+  return word && decl.variants && Object.hasOwn(decl.variants, word) ? decl.variants[word] : "";
+}
+function nearVariant(word, variants) {
+  return variants.find((v) => v.toLowerCase() === word.toLowerCase()) || (word.length >= 3 ? nearestDeclaredMarkerName(word, variants) : null);
+}
+function warnUnknownVariant(env, meta, decl) {
+  const word = meta.name;
+  if (!word)
+    return;
+  const variants = Object.keys(decl.variants || {});
+  if (variants.includes(word))
+    return;
+  const near = nearVariant(word, variants);
+  warn(env, meta.__line, "unknown_variant", `"${word}" is not a variant of @${meta.kind}, so it adds no styling. ` + (variants.length ? `Variants: ${variants.join(", ")}.` : `@${meta.kind} has no variants.`) + (near ? ` Did you mean "${near}"?` : ""), meta);
+}
+function warnNearMissVariant(env, meta, kind, variants) {
+  const words = [...variants.keys()];
+  const near = nearVariant(meta.name, words);
+  if (!near)
+    return;
+  warn(env, meta.__line, "unknown_variant", `"${meta.name}" is not a variant of @${kind}, so it is only a ${kind} name and adds no styling. ` + `Variants: ${words.join(", ")}. Did you mean "${near}"?`, meta);
+}
+function plugin(md, pluginOptions = {}) {
+  const options = {
+    preferPagesInSpreads: false,
+    ...pluginOptions
+  };
+  const declaredMarkers = options.declaredMarkers instanceof Map && options.declaredMarkers.size > 0 ? options.declaredMarkers : buildDeclaredMarkerRegistry([]);
+  const declaredWords = declaredKindWords(declaredMarkers);
+  const locationVariants = declaredMarkers.locationVariants || buildDeclaredMarkerRegistry([]).locationVariants;
+  function markerBlock(state, startLine, endLine, silent) {
+    const pos = state.bMarks[startLine] + state.tShift[startLine];
+    const max = state.eMarks[startLine];
+    const line = state.src.slice(pos, max);
+    const parsed = parseMarkerLine(line, declaredWords);
+    if (!parsed)
+      return false;
+    if (silent)
+      return true;
+    state.env.__layoutMarkersUsed = true;
+    const token = state.push("layout_marker", "", 0);
+    token.meta = parsed;
+    token.meta.__line = startLine + 1;
+    if (parsed.__ambiguousBareToken) {
+      delete parsed.__ambiguousBareToken;
+      warn(state.env, startLine + 1, "ambiguous_marker_token", "A bare marker token after a key=value attribute is being interpreted as the marker name (or an extra class). Use comma-separated classes (class=a,b) or .class shorthand instead.", parsed);
+    }
+    if (parsed.__unknownTokens) {
+      const unknown = parsed.__unknownTokens;
+      delete parsed.__unknownTokens;
+      for (const t of unknown) {
+        warn(state.env, startLine + 1, "unrecognized_marker_token", `@${parsed.kind}: "${t}" is not something a marker understands, so it was kept verbatim as a class name. Write a class as .my-class (or {.my-class}), an id as #my-id, and anything else as key=value.` + proseEscapeHint(parsed.kind), parsed);
+      }
+    }
+    if (parsed.__extraBareTokens) {
+      const { tokens, named } = parsed.__extraBareTokens;
+      delete parsed.__extraBareTokens;
+      const list = tokens.map((t) => `"${t}"`).join(", ");
+      warn(state.env, startLine + 1, "extra_bare_marker_token", named ? `@${parsed.kind}: only the first plain word (${list.split(", ")[0]}) is used as the name; the rest (${tokens.slice(1).map((t) => `"${t}"`).join(", ")}) became class names instead. Quote a name that contains spaces ("${tokens.join(" ")}"), or write classes as .${tokens.slice(1).join(" .")}.` : `@${parsed.kind}: ${list} are several plain words, but a marker has only one name slot — so NONE of them was used as the name and they all became class names instead. Quote a name that contains spaces ("${tokens.join(" ")}"), or write classes as .${tokens.join(" .")}.` + proseEscapeHint(parsed.kind), parsed);
+    }
+    state.line = startLine + 1;
+    return true;
+  }
+  md.block.ruler.before("paragraph", "layout_marker", markerBlock, {
+    alt: ["paragraph", "reference", "blockquote", "list"]
+  });
+  const SCOPE_CLOSE_ORDER = ["section", "page", "spread", "chapter"];
+  function scanForMistypedMarkers(state) {
+    for (let tokenIndex = 0;tokenIndex < state.tokens.length; tokenIndex++) {
+      const tok = state.tokens[tokenIndex];
+      if (tok.type !== "inline" || !tok.map)
+        continue;
+      const opener = state.tokens[tokenIndex - 1];
+      if (!opener || opener.type !== "paragraph_open")
+        continue;
+      const lines = tok.content.split(`
+`);
+      for (let i = 0;i < lines.length; i++) {
+        const m = /^@([A-Za-z][A-Za-z0-9-]*)(?=\s|$)/.exec(lines[i].trim());
+        if (!m)
+          continue;
+        if (KNOWN_KINDS.includes(m[1]))
+          continue;
+        const suggestion = nearestKind(m[1]);
+        if (!suggestion)
+          continue;
+        warn(state.env, tok.map[0] + i + 1, "unknown_marker", `"@${m[1]}" is not a marker Gutterpress knows, so this line was left as ordinary text. Did you mean "@${suggestion}"? (marker names are lower-case).`, null);
+      }
+    }
+  }
+  md.core.ruler.after("block", "layout_transform", function(state) {
+    scanForUnknownDeclaredMarkers(state, declaredMarkers);
+    if (!state.env.__layoutMarkersUsed)
+      return;
+    scanForMistypedMarkers(state);
+    const out = [];
+    const declaredFrames = [];
+    function declaredFrameIndex(kind) {
+      for (let i = declaredFrames.length - 1;i >= 0; i--) {
+        if (declaredFrames[i].kind === kind)
+          return i;
+      }
+      return -1;
+    }
+    function closeDeclaredFrame(kind) {
+      const at = declaredFrameIndex(kind);
+      if (at === -1)
+        return false;
+      drainDeclaredFrames(at);
+      return true;
+    }
+    function sectionAbove(length) {
+      const section = stack.get("section");
+      return !!section && section.inColumns && declaredFrameIndex("columns") === length - 1;
+    }
+    function sectionHostDepth() {
+      const section = stack.get("section");
+      if (section && !section.inColumns)
+        return 0;
+      return declaredFrameIndex("columns") + 1;
+    }
+    function drainDeclaredFrames(keep = 0) {
+      while (declaredFrames.length > keep) {
+        if (sectionAbove(declaredFrames.length)) {
+          stack.close("section");
+          continue;
+        }
+        const frame = declaredFrames.pop();
+        out.push(new state.Token("layout_component_close", frame.tag, -1));
+      }
+    }
+    function drainDeclaredFramesAtEof() {
+      while (declaredFrames.length) {
+        if (sectionAbove(declaredFrames.length)) {
+          stack.close("section");
+          continue;
+        }
+        const frame = declaredFrames.pop();
+        if (!frame.decl.autoCloseAtEof) {
+          warn(state.env, frame.line || 0, "declared_marker_eof_close", `An open @${frame.kind} reached end-of-document; closing it automatically. Add ` + `@end-${frame.kind} to close it explicitly, or declare autoCloseAt: ["eof"] on this ` + `marker if running to end-of-document is expected.`, null);
+        }
+        out.push(new state.Token("layout_component_close", frame.tag, -1));
+      }
+    }
+    function openDeclaredMarker(meta, decl) {
+      const t = new state.Token("layout_component_open", decl.tag, 1);
+      const variant = meta.name || decl.presetVariant || null;
+      warnUnknownVariant(state.env, meta, decl);
+      t.meta = {
+        line: meta.__line,
+        component: meta.kind,
+        kind: decl.baseKind,
+        variant,
+        attrs: meta.attrs || {},
+        labelled: false
+      };
+      const variantClass = variantClassFor(decl, variant);
+      const baseClass = [decl.classBase, variantClass].filter(Boolean).join(" ");
+      addClasses(t, baseClass, meta.attrs && meta.attrs.class ? meta.attrs.class : "");
+      attachDataAttrs(t, decl.baseKind, variant, meta.attrs || {});
+      out.push(t);
+      if (!decl.selfClosing)
+        declaredFrames.push({ kind: decl.baseKind, tag: decl.tag, decl, line: meta.__line });
+      if (decl.label) {
+        const value = meta.attrs && meta.attrs[decl.label.attr];
+        if (value) {
+          const labelToken = new state.Token("html_block", "", 0);
+          labelToken.content = `<${decl.label.tag} class="${escapeAttr(decl.label.class)}">${escapeHtml(value)}</${decl.label.tag}>
+`;
+          out.push(labelToken);
+          t.meta.labelled = true;
+        }
+      }
+      if (decl.selfClosing)
+        out.push(new state.Token("layout_component_close", decl.tag, -1));
+    }
+    const stack = {
+      frames: [],
+      get(kind) {
+        return this.frames.find((f) => f.kind === kind) || null;
+      },
+      has(kind) {
+        return this.frames.some((f) => f.kind === kind);
+      },
+      open(frame, openToken) {
+        out.push(openToken);
+        this.frames.push(frame);
+      },
+      _pop(kind) {
+        const at = this.frames.findIndex((f) => f.kind === kind);
+        if (at === -1)
+          return;
+        this.frames.splice(at, 1);
+        out.push(new state.Token(`layout_${kind}_close`, "div", -1));
+      },
+      close(kind) {
+        if (!this.has(kind))
+          return;
+        for (const inner of SCOPE_CLOSE_ORDER) {
+          if (inner === kind)
+            break;
+          this._pop(inner);
+        }
+        this._pop(kind);
+      },
+      closeAll() {
+        for (const kind of SCOPE_CLOSE_ORDER)
+          this._pop(kind);
+      }
+    };
+    function openChapter(meta) {
+      const t = new state.Token("layout_chapter_open", "div", 1);
+      t.meta = { line: meta.__line };
+      const variant = locationVariants.chapter.get(meta.name);
+      const label = variant ? "" : meta.name;
+      const classes = [variant?.class, meta.attrs?.class].filter(Boolean).join(" ");
+      addClasses(t, "chapter", classes);
+      attachDataAttrs(t, "chapter", label, meta.attrs || {});
+      const explicit = (classes.match(/(?:^|\s)(chapter-\d+)(?=\s|$)/) || [])[1] || "";
+      const fromAttr = meta.attrs?.ch ? `chapter-${meta.attrs.ch}` : "";
+      stack.open({
+        kind: "chapter",
+        label: label || "",
+        counterClass: explicit || fromAttr,
+        openerEmitted: false
+      }, t);
+    }
+    function openSpread(meta) {
+      const t = new state.Token("layout_spread_open", "div", 1);
+      t.meta = { line: meta.__line };
+      addClasses(t, "spread", meta.attrs && meta.attrs.class ? meta.attrs.class : "");
+      attachDataAttrs(t, "spread", meta.name, meta.attrs || {});
+      stack.open({
+        kind: "spread",
+        classes: meta.attrs && meta.attrs.class || "",
+        noPagesYet: true,
+        sawAnyPage: false
+      }, t);
+    }
+    function openPage(meta) {
+      const chapter = stack.get("chapter");
+      const t = new state.Token("layout_page_open", "div", 1);
+      t.meta = { line: meta.__line };
+      const explicit = meta.attrs && meta.attrs.class ? meta.attrs.class : "";
+      const counterClass = chapter ? chapter.counterClass : "";
+      const tokens = explicit ? explicit.split(/\s+/) : [];
+      const withCounter = counterClass && !tokens.includes(counterClass) ? explicit ? `${explicit} ${counterClass}` : counterClass : explicit;
+      const variant = locationVariants.page.get(meta.name);
+      if (!variant && meta.name)
+        warnNearMissVariant(state.env, meta, "page", locationVariants.page);
+      const merged = [variant?.class, withCounter].filter(Boolean).join(" ");
+      addClasses(t, "page", merged);
+      attachDataAttrs(t, "page", meta.name, meta.attrs || {});
+      const label = chapter ? chapter.label : "";
+      if (label)
+        t.attrSet("data-chapter-label", label);
+      stack.open({ kind: "page", classes: explicit }, t);
+      if (label && !chapter.openerEmitted) {
+        const opener = new state.Token("html_block", "", 0);
+        opener.content = `<div class="chapter-opener" data-chapter-label="${escapeAttr(label)}">${escapeHtml(label)}</div>
+`;
+        out.push(opener);
+        chapter.openerEmitted = true;
+      }
+      const spread = stack.get("spread");
+      if (spread) {
+        spread.sawAnyPage = true;
+        spread.noPagesYet = false;
+      } else if (options.preferPagesInSpreads) {
+        warn(state.env, meta.__line || 0, "page_outside_spread", "@page used outside of a spread; allowed, but spreads are recommended for deliberate grouping.", meta);
+      }
+    }
+    function sectionMetaFor(meta, decl) {
+      const attrs = meta.attrs || {};
+      const variant = meta.name || decl.presetVariant || null;
+      warnUnknownVariant(state.env, meta, decl);
+      const variantClass = variantClassFor(decl, variant);
+      const cls = [decl.classBase, variantClass, attrs.class].filter(Boolean).join(" ");
+      return {
+        kind: "section",
+        name: null,
+        attrs: cls ? { ...attrs, class: cls } : attrs,
+        __line: meta.__line,
+        __component: { component: meta.kind, kind: decl.baseKind, variant, attrs }
+      };
+    }
+    function openSection(meta, inColumns = false) {
+      const t = new state.Token("layout_section_open", "div", 1);
+      const component = meta.__component || null;
+      const variant = component ? null : locationVariants.section.get(meta.name);
+      addClasses(t, "section", [variant?.class, meta.attrs && meta.attrs.class].filter(Boolean).join(" "));
+      if (component)
+        attachDataAttrs(t, component.kind, component.variant, meta.attrs || {});
+      else
+        attachDataAttrs(t, "section", meta.name, meta.attrs || {});
+      t.meta = {
+        line: meta.__line,
+        ...component || {},
+        ...meta.__continued ? { continued: true } : {}
+      };
+      stack.open({
+        kind: "section",
+        classes: meta.attrs && meta.attrs.class || "",
+        sawContent: false,
+        ...inColumns ? { inColumns: true } : {},
+        meta: { name: meta.name || null, attrs: { ...meta.attrs || {} }, component },
+        openToken: t
+      }, t);
+    }
+    function warnIfEmptyDecoratedSection(closingKind, closingLine) {
+      const sec = stack.get("section");
+      if (!sec || sec.sawContent)
+        return;
+      const attrs = sec.meta && sec.meta.attrs || {};
+      const decorations = [];
+      for (const c of (attrs.class || "").split(/\s+/).filter(Boolean))
+        decorations.push(`.${c}`);
+      for (const [k, v] of Object.entries(attrs)) {
+        if (k === "class")
+          continue;
+        decorations.push(k === "id" ? `#${v}` : `${k}=${v}`);
+      }
+      if (!decorations.length)
+        return;
+      const openLine = sec.openToken && sec.openToken.meta && Number.isFinite(sec.openToken.meta.line) ? sec.openToken.meta.line : closingLine;
+      warn(state.env, openLine, "empty_section", `This @section (${decorations.join(" ")}) was closed by the @${closingKind} on line ${closingLine} with no content between the two markers, so its styling applies to an empty element and nothing prints the layout it asked for. Delete one of the two markers, or move the content that belongs inside the section between them.`, null);
+    }
+    for (let i = 0;i < state.tokens.length; i++) {
+      const tok = state.tokens[i];
+      if (tok.type !== "layout_marker") {
+        const openSectionFrame = stack.get("section");
+        if (openSectionFrame)
+          openSectionFrame.sawContent = true;
+        out.push(tok);
+        continue;
+      }
+      let meta = tok.meta || {};
+      let kind = meta.kind;
+      const line = meta.__line || 0;
+      if (declaredMarkers) {
+        const closing = kind.startsWith("end-");
+        const sectionDecl = declaredMarkers.get(closing ? kind.slice(4) : kind);
+        if (sectionDecl && sectionDecl.section) {
+          if (closing) {
+            kind = "end-section";
+          } else {
+            meta = sectionMetaFor(meta, sectionDecl);
+            kind = "section";
+          }
+        }
+      }
+      if (kind === "chapter") {
+        drainDeclaredFrames();
+        stack.close("chapter");
+        openChapter(meta);
+        continue;
+      }
+      if (kind === "spread") {
+        if (stack.has("spread")) {
+          warn(state.env, line, "nested_spread", "@spread encountered while another spread is open; closing the previous spread automatically.", meta);
+        }
+        drainDeclaredFrames();
+        stack.close("spread");
+        openSpread(meta);
+        continue;
+      }
+      if (kind === "page") {
+        drainDeclaredFrames();
+        stack.close("page");
+        openPage(meta);
+        continue;
+      }
+      if (kind === "section") {
+        const keep = sectionHostDepth();
+        drainDeclaredFrames(keep);
+        warnIfEmptyDecoratedSection("section", line);
+        stack.close("section");
+        const spread = stack.get("spread");
+        if (spread && spread.noPagesYet) {
+          warn(state.env, line, "spread_without_pages", "@section inside a spread without an explicit @page. Allowed (adhoc spread), but explicit @page markers give stronger control.", meta);
+        }
+        if (meta.name && !locationVariants.section.has(meta.name)) {
+          warnNearMissVariant(state.env, meta, "section", locationVariants.section);
+        }
+        openSection(meta, keep > 0);
+        continue;
+      }
+      if (kind === "continue") {
+        const section = stack.get("section");
+        if (!section || !section.meta) {
+          warn(state.env, line, "continue_without_section", "@continue used without an open @section; ignoring marker.", meta);
+          continue;
+        }
+        const keep = sectionHostDepth();
+        drainDeclaredFrames(keep);
+        const contMeta = {
+          name: section.meta.name,
+          attrs: { ...section.meta.attrs || {} },
+          __continued: true
+        };
+        delete contMeta.attrs.id;
+        if (section.meta.component)
+          contMeta.__component = section.meta.component;
+        contMeta.__line = line;
+        const cls = (contMeta.attrs.class || "").split(/\s+/).filter(Boolean);
+        if (!cls.includes("gp-continued"))
+          cls.push("gp-continued");
+        contMeta.attrs.class = cls.join(" ");
+        stack.close("section");
+        openSection(contMeta, keep > 0);
+        continue;
+      }
+      if (kind === "page-break") {
+        const t = new state.Token("layout_page_break", "div", 0);
+        t.meta = { line };
+        attachBreak(t, "gp-page-break", meta.attrs);
+        out.push(t);
+        continue;
+      }
+      if (kind === "column-break") {
+        const t = new state.Token("layout_column_break", "div", 0);
+        t.meta = { line };
+        attachBreak(t, "gp-column-break", meta.attrs);
+        out.push(t);
+        continue;
+      }
+      if (kind === "end-section") {
+        drainDeclaredFrames(sectionHostDepth());
+        warnIfEmptyDecoratedSection("end-section", line);
+        stack.close("section");
+        continue;
+      }
+      if (declaredMarkers) {
+        const openDecl = declaredMarkers.get(kind);
+        if (openDecl) {
+          if (openDecl.deprecated) {
+            warn(state.env, line, "deprecated_marker", `@${kind} is deprecated: ${openDecl.deprecated}`, meta);
+            continue;
+          }
+          closeDeclaredFrame(openDecl.baseKind);
+          openDeclaredMarker(meta, openDecl);
+          continue;
+        }
+        if (kind.startsWith("end-")) {
+          const closeDecl = declaredMarkers.get(kind.slice(4));
+          if (closeDecl) {
+            if (closeDecl.deprecated) {
+              warn(state.env, line, "deprecated_marker", `@${kind} is deprecated: ${closeDecl.deprecated}`, meta);
+              continue;
+            }
+            if (!closeDeclaredFrame(closeDecl.baseKind)) {
+              warn(state.env, line, "declared_marker_close_without_open", closeDecl.selfClosing ? `@${kind} is not a marker: @${closeDecl.baseKind} is self-closing and has nothing to close; ignoring marker.` : `@${kind} used without an open @${closeDecl.baseKind}; ignoring marker.`, meta);
+            }
+            continue;
+          }
+        }
+      }
+    }
+    const eofSpread = stack.get("spread");
+    if (eofSpread && !eofSpread.sawAnyPage) {
+      warn(state.env, 0, "spread_eof_close", "An open @spread reached end-of-document; closing it automatically.", null);
+    }
+    drainDeclaredFramesAtEof();
+    stack.closeAll();
+    state.tokens = out;
+  });
+  if (declaredMarkers && [...declaredMarkers.values()].some((d) => d.validate)) {
+    md.core.ruler.push("gp_component_validate", function(state) {
+      let lines = null;
+      const tokens = state.tokens;
+      for (let i = 0;i < tokens.length; i++) {
+        const tok = tokens[i];
+        const isSection = tok.type === "layout_section_open" && tok.meta && tok.meta.component && !tok.meta.continued;
+        if (tok.type !== "layout_component_open" && !isSection)
+          continue;
+        const decl = declaredMarkers.get(tok.meta.component);
+        if (!decl || !decl.validate)
+          continue;
+        if (!lines)
+          lines = state.src.split(`
+`);
+        const from = i + (tok.meta.labelled ? 2 : 1);
+        runComponentValidate(state.env, decl, tok.meta, tokens.slice(from, blockEnd(tokens, i)), lines);
+      }
+    });
+  }
+  const renderBreak = (tokens, idx, options2, env, self) => `<div${self.renderAttrs(tokens[idx])}></div>
+`;
+  md.renderer.rules.layout_page_break = renderBreak;
+  md.renderer.rules.layout_column_break = renderBreak;
+  md.renderer.rules.layout_marker = () => "";
+}
+var NO_MARGIN_BOXES = [
+  "top-left-corner",
+  "top-left",
+  "top-center",
+  "top-right",
+  "top-right-corner",
+  "bottom-left-corner",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right",
+  "bottom-right-corner",
+  "left-top",
+  "left-middle",
+  "left-bottom",
+  "right-top",
+  "right-middle",
+  "right-bottom"
+].map((box) => `  @${box} { content: none; }`).join(`
+`);
+var MARKER_CSS = `
+/* The UA default of 8px body margin is a screen affordance with no meaning
+   in paged media, and engines disagree about it: a polyfill that treats the
+   page div as the page box drops it, native print keeps it. Left in place it
+   insets EVERY page's content by 8px per side, and -- measured, 300dpi,
+   6x4in sheet -- it is what stops a full-width block from reaching the
+   paper: it lands at 0.080..5.917in of a 6in sheet instead of
+   0.000..6.000in, because width:100% resolves against the BODY content box,
+   not the page's. Zeroing it here (first in the cascade) makes the two
+   agree. Authors who want a body margin still just declare one. */
+body { margin: 0; }
+
+.gp-page-break { break-before: page; }
+.page { break-before: page; }
+.spread { break-before: page; }
+:where(.page, .spread) { position: relative; display: flow-root; box-sizing: border-box; min-height: calc(var(--gp-content-h, 1px) - 1px); }
+.gp-column-break { break-after: column; height: 0; font-size: 0; line-height: 0; visibility: hidden; }
+
+:where(h1,h2,h3,h4,h5,h6) { break-after: avoid; }
+/* A lead-in paragraph ("**ROLL A DIE!**" above a roll table, "You will need:"
+   above a list) stays with the table or list it introduces, the way a heading
+   stays with what follows it -- otherwise the label can end a column or page
+   with its table starting on the next (#370). Standard break-after; the
+   :has() selector is Chromium's own. :where() keeps specificity at zero so an
+   author rule such as p { break-after: auto } wins. Deliberately table/ul/ol only,
+   also when a @section wraps it (the second rule): the lead-in then keeps with
+   the section that opens with the table or list. */
+:where(p):has(+ :where(table, ul, ol)) { break-after: avoid; }
+:where(p):has(+ :where(.section) > :where(table, ul, ol):first-child) { break-after: avoid; }
+:where(img, svg, video) { max-width: 100%; }
+:where(p > img:only-child, figure > img) { width: fit-content; max-width: 100%; height: auto; vertical-align: bottom; }
+:where(p) > :where(img:not([class])) { max-height: calc(var(--gp-content-h) - 4px); object-fit: contain; }
+:where(figure) { break-inside: avoid; }
+
+/* Core page variants — \`@page blank\` and \`@page full-bleed\` (CORE_DECLARED_MARKERS).
+   Each is the \`.page\` the marker already emits plus one class; the class
+   assigns the page to a NAMED page, and the named \`@page\` block below is
+   plain CSS Paged Media. Authors never write these names.
+
+   SPEC GAP FILLED: none. Named pages (\`@page <name>\`, \`page:\`) and margin
+   box \`content: none\` are standard and implemented in Chromium; this is
+   author vocabulary that expands to them (permanent, like @columns), not a
+   shim, so nothing here is deleted when Chrome catches up. Both pages are
+   named \`gp-\`, which the shrink-to-fit audit (engine/compiler/build.ts)
+   leaves out of its per-page limits, so they cannot loosen it for other pages.
+
+   The folio still COUNTS on these pages (only what is drawn is cleared), and
+   a book that assigns \`page:\` to every \`.page\` in its own unlayered CSS
+   overrides the assignment, as any unlayered rule overrides this layer. */
+@page gp-page-blank {
+${NO_MARGIN_BOXES}
+}
+.page.gp-page-blank { page: gp-page-blank; }
+
+/* full-bleed: zero page margin, so the content box IS the sheet. The margin
+   boxes are cleared too — with zero margins they would land on the trim line. */
+@page gp-page-full-bleed {
+  margin: 0;
+${NO_MARGIN_BOXES}
+}
+.page.gp-page-full-bleed { page: gp-page-full-bleed; }
+
+`;
+
+// src/lib/markdown/gutterpress-css.ts
+var GUTTERPRESS_CSS = `
+/* gp-* author image/block vocabulary. One vocabulary, gp-* only — the
+   pre-vocabulary utility names (.center/.float-left/.float-right/
+   .full-width/.full-bleed) were REMOVED when gp-* shipped; books rename
+   the classes in their markdown (see the migration note). Source ORDER is
+   the contract — see the doctrine comment above. */
+
+/* flow positions */
+.gp-left {
+  float: left;
+  margin: 0 var(--gp-gap, 1em) var(--gp-gap, 1em) 0;
+  max-width: 50%;
+}
+.gp-right {
+  float: right;
+  margin: 0 0 var(--gp-gap, 1em) var(--gp-gap, 1em);
+  max-width: 50%;
+}
+.gp-center {
+  display: block;
+  float: none;
+  margin-left: auto;
+  margin-right: auto;
+  max-width: 100%;
+}
+.gp-full {
+  display: block;
+  float: none;
+  width: 100%;
+  max-width: 100%;
+}
+@page gp-full-bleed { margin-left: 0; margin-right: 0; }
+.gp-bleed {
+  display: block;
+  float: none;
+  break-before: page;
+  page: gp-full-bleed;
+  max-width: none;
+  width: 100%;
+  margin-left: 0;
+  margin-right: 0;
+}
+
+/* sizes — AFTER the flow positions so max-width:100% lifts the floats' 50%
+   cap at equal specificity */
+.gp-size-10 { width: 10%; max-width: 100%; }
+.gp-size-20 { width: 20%; max-width: 100%; }
+.gp-size-30 { width: 30%; max-width: 100%; }
+.gp-size-40 { width: 40%; max-width: 100%; }
+.gp-size-50 { width: 50%; max-width: 100%; }
+.gp-size-60 { width: 60%; max-width: 100%; }
+.gp-size-70 { width: 70%; max-width: 100%; }
+.gp-size-80 { width: 80%; max-width: 100%; }
+.gp-size-90 { width: 90%; max-width: 100%; }
+
+/* float clearance presets — consumed by var(--gp-gap) in the float rules
+   above and by .gp-shape's shape-margin below; --gp-gap itself is
+   author-settable CSS */
+.gp-tight { --gp-gap: 0.5em; }
+.gp-loose { --gp-gap: 2em; }
+
+/* column runs — plain CSS Multi-column, emitted by the core @columns marker
+   (markers.js): @columns [1-5] ... @end-columns is the ONE way to lay
+   content out in columns, and @column-break moves to the next column.
+   The classes below are the CSS that marker emits, not author vocabulary.
+
+   Permanent vocabulary, not a shim: Chromium implements multicol natively
+   and these rules are the standard properties verbatim, so there is no
+   spec gap here to remove later. Deliberately minimal — column-fill is
+   NOT set (the CSS initial balance applies).
+   Themes style a run through two tokens instead of writing column rules:
+     --gp-column-gap   default 1.5em
+     --gp-column-rule  default none (any column-rule shorthand value)
+   Both hooks sit at zero specificity (:where), so any author rule wins.
+   .gp-columns is two columns on its own; a count class (bare @columns
+   emits gp-columns-2) wins because it comes later at the same specificity. */
+:where(.gp-columns, .gp-columns-1, .gp-columns-2, .gp-columns-3, .gp-columns-4, .gp-columns-5) {
+  column-gap: var(--gp-column-gap, 1.5em);
+  column-rule: var(--gp-column-rule, none);
+}
+.gp-columns { columns: 2; }
+.gp-columns-1 { columns: 1; }
+.gp-columns-2 { columns: 2; }
+.gp-columns-3 { columns: 3; }
+.gp-columns-4 { columns: 4; }
+.gp-columns-5 { columns: 5; }
+
+/* fragmentation controls — generic pagination utilities for any element,
+   independent of the column vocabulary above (a book reached for
+   these just as often outside a multicol run: keeping a card whole,
+   forcing a section to start a fresh page). Standard properties only —
+   this project is Chromium-only (CLAUDE.md), so there are no legacy
+   page-break-* twins to also emit. One name each. */
+.gp-no-break { break-inside: avoid; }
+.gp-break-before { break-before: page; }
+
+/* shape wrap — text follows the image's alpha silhouette instead of its
+   rectangular box. shape-outside only applies to floats, so this is inert
+   without .gp-left/.gp-right (and under .gp-pin, which un-floats). The
+   shape URL cannot be written in CSS (url() contexts can't read attr()),
+   so the image renderer rule (images.ts) mirrors the src into an inline
+   --gp-shape:url(...) custom property whenever it sees this class --
+   authors only ever type the class. threshold 0.2 ignores near-transparent
+   anti-aliasing halos; shape-margin shares the float-gap vocabulary. */
+img.gp-shape {
+  shape-outside: var(--gp-shape);
+  shape-image-threshold: 0.2;
+  shape-margin: var(--gp-gap, 1em);
+}
+
+/* pin — within the nearest positioned ancestor (.page/.spread, rule above).
+   The four insets are the pin box: 0 (the text block's edge) unless an
+   engine set --gp-pin-<edge> on the page root for an edge a pin uses (the
+   art-safe line). Non-auto insets and the explicit centers are
+   load-bearing; see doctrine comment. */
+.gp-pin {
+  position: absolute;
+  top: var(--gp-pin-top, 0px);
+  right: var(--gp-pin-right, 0px);
+  bottom: var(--gp-pin-bottom, 0px);
+  left: var(--gp-pin-left, 0px);
+  align-self: center;
+  justify-self: center;
+  margin: 0;
+  max-width: 100%;
+}
+
+/* pin edge modifiers — AFTER .gp-pin to beat its center defaults;
+   justify-self is inert on in-flow floats, so gp-left/gp-right safely do
+   double duty as flow float + pin edge */
+.gp-top { align-self: start; }
+.gp-bottom { align-self: end; }
+.gp-left { justify-self: start; }
+.gp-right { justify-self: end; }
+
+/* the escape hatch — the paper's edge, past the printer's safe area: the
+   pin box loses its art-safe insets. Set on the pin itself, so it beats the
+   values the page root hands down. */
+.gp-pin.gp-flush {
+  --gp-pin-top: 0px;
+  --gp-pin-right: 0px;
+  --gp-pin-bottom: 0px;
+  --gp-pin-left: 0px;
+}
+
+/* wrapper-margin neutralization (same pattern and rationale as the
+   .gp-bleed paragraph-margin note in the doctrine comment; for pin, the
+   emptied paragraph would otherwise leave a phantom margin gap in flow) */
+:where(p:has(> img.gp-bleed:only-child)) { margin: 0; }
+:where(p:has(> img.gp-pin:only-child)) { margin: 0; }
+
+/* depth — a named ladder for z-index, so books stop hand-tuning bare
+   integers. A real book measured 21 z-index declarations using only four
+   distinct values (-1, 0, 1, 2), each written literally at its use site.
+   The custom properties are the author-settable surface (a book needing a
+   deeper stack raises them once); the classes are the shorthand.
+
+   NOT named "layer": CSS Paged Media 3 §3.1 already defines "page layers"
+   (page background, canvas, borders, contents, margin boxes) and those are
+   parts of the PAGE BOX, not a z-ladder for content. Reusing the word for a
+   different concept would collide with the spec vocabulary this project
+   tracks. The pin EDGE modifiers already own .gp-top/.gp-bottom, so the
+   ladder avoids those words too.
+
+   .gp-behind is the one that earns its place: it puts a pinned image UNDER
+   the page's text, which is otherwise impossible to express without a bare
+   negative z-index. "Above" needs no class — an out-of-flow pin already
+   paints above in-flow content.
+
+   Two things silently defeat .gp-behind, neither visible at the use site:
+     - a stacking context on the .page/.spread ancestor (z-index, isolation,
+       opacity, filter, transform on it traps the negative layer inside).
+       Core keeps .page/.spread at 'position: relative; z-index: auto'
+       precisely so they are not stacking contexts.
+     - a clipping ancestor (overflow other than visible) — but only where
+       the art actually overhangs that ancestor's clip box on a clipped
+       axis: the overhang is cut off, the same mechanism that clips a
+       .gp-bleed plate back to the wrapper's width. Clipping never reorders
+       layers — within-bounds art under a clipping .page prints whole and
+       still behind (measured; see the build audit's comment in
+       engine/compiler/build.ts), and a static wrapper's overflow never
+       binds an abspos .gp-pin at all.
+   The build-time engine.layer.trapped audit reports both against the live
+   ancestor chain. printsafe/page-containment is only an early source hint for
+   declarations written directly on .page/.spread. */
+:root {
+  --gp-z-behind: -1;
+  --gp-z-base: 0;
+  --gp-z-raised: 1;
+  --gp-z-front: 2;
+}
+.gp-behind { z-index: var(--gp-z-behind); }
+.gp-base   { z-index: var(--gp-z-base); }
+.gp-raised { z-index: var(--gp-z-raised); }
+.gp-front  { z-index: var(--gp-z-front); }
+
+/* GFM-style alert/callout boxes (#237) — the DOM gfm-alerts.ts emits from
+   "> [!TYPE]" blockquote syntax when a project opts into the bundled
+   gutterpress-gfm-alerts feature (BUILTIN_OPTIONAL_PLUGINS, renderer.ts).
+   The plugin is optional and inert by default; these rules are equally
+   inert wherever the classes never appear, exactly like every other
+   utility above, so shipping them costs nothing to a book that has not
+   turned the feature on.
+
+   This is authored-COMPONENT vocabulary, not the @marker structural family
+   (markers.js/MARKER_CSS) — CLAUDE.md §6 splits the two core CSS blocks by
+   ROLE, and an author-facing box an author invokes via inline syntax is the
+   same role as every other gp-* utility here, not page/chapter/section DOM.
+
+   Deliberately minimal (CLAUDE.md "thin over capable" / the issue's own
+   "a rule and a label"): a left border plus a bold label, :where()'d to
+   zero specificity so a theme's own (unlayered) rule for any of these
+   classes wins outright regardless of selector weight — see the
+   cascade-layers note atop this file. Five semantic accent colors (the same
+   NOTE/TIP/IMPORTANT/WARNING/CAUTION hues GitHub's own alerts use — a
+   long-established, non-proprietary convention, not DC branding) are
+   exposed as :root custom properties, the same author-settable-surface
+   pattern as the --gp-z-* ladder above: a book retints every alert of one
+   type by overriding a single property, no specificity fight required.
+   --gp-alert-color cascades from the type modifier down to .gp-alert-title
+   through ordinary CSS inheritance (the title is always a DOM descendant of
+   the box), so it is set in exactly five places, not ten. */
+:root {
+  --gp-alert-note-color: #0969da;
+  --gp-alert-tip-color: #1a7f37;
+  --gp-alert-important-color: #8250df;
+  --gp-alert-warning-color: #9a6700;
+  --gp-alert-caution-color: #cf222e;
+}
+:where(.gp-alert) {
+  margin: 1em 0;
+  padding: 0.5em 1em;
+  border-left: 0.25em solid var(--gp-alert-color, currentColor);
+}
+:where(.gp-alert-title) {
+  margin: 0 0 0.5em;
+  font-weight: bold;
+  color: var(--gp-alert-color, inherit);
+}
+:where(.gp-alert-note)      { --gp-alert-color: var(--gp-alert-note-color); }
+:where(.gp-alert-tip)       { --gp-alert-color: var(--gp-alert-tip-color); }
+:where(.gp-alert-important) { --gp-alert-color: var(--gp-alert-important-color); }
+:where(.gp-alert-warning)   { --gp-alert-color: var(--gp-alert-warning-color); }
+:where(.gp-alert-caution)   { --gp-alert-color: var(--gp-alert-caution-color); }
+`;
+var GP_CLASSES = new Set([
+  "gp-left",
+  "gp-right",
+  "gp-center",
+  "gp-full",
+  "gp-bleed",
+  "gp-size-10",
+  "gp-size-20",
+  "gp-size-30",
+  "gp-size-40",
+  "gp-size-50",
+  "gp-size-60",
+  "gp-size-70",
+  "gp-size-80",
+  "gp-size-90",
+  "gp-tight",
+  "gp-loose",
+  "gp-columns",
+  "gp-columns-1",
+  "gp-columns-2",
+  "gp-columns-3",
+  "gp-columns-4",
+  "gp-columns-5",
+  "gp-page-blank",
+  "gp-page-full-bleed",
+  "gp-no-break",
+  "gp-break-before",
+  "gp-shape",
+  "gp-pin",
+  "gp-top",
+  "gp-bottom",
+  "gp-flush",
+  "gp-behind",
+  "gp-base",
+  "gp-raised",
+  "gp-front",
+  "gp-alert",
+  "gp-alert-title",
+  "gp-alert-note",
+  "gp-alert-tip",
+  "gp-alert-important",
+  "gp-alert-warning",
+  "gp-alert-caution",
+  "gp-page-break",
+  "gp-column-break",
+  "gp-continued"
+]);
+
+// src/lib/markdown/gp-pin-scope.js
+function warn2(env, line, type, message, severity) {
+  if (!env.layoutWarnings)
+    env.layoutWarnings = [];
+  env.layoutWarnings.push(severity ? { line, type, message, severity } : { line, type, message });
+}
+function editDistance2(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1;i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1;j <= b.length; j++) {
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+    prev = cur;
+  }
+  return prev[b.length];
+}
+function nearestGpClass(cls) {
+  const threshold = Math.max(2, Math.floor(cls.length / 3));
+  let best = null;
+  let bestDistance = Infinity;
+  for (const known of GP_CLASSES) {
+    const d = editDistance2(cls, known);
+    if (d < bestDistance) {
+      bestDistance = d;
+      best = known;
+    }
+  }
+  return best !== null && bestDistance > 0 && bestDistance <= threshold ? best : null;
+}
+function hasPinClass(token) {
+  const cls = token.attrGet && token.attrGet("class");
+  return typeof cls === "string" && cls.split(/\s+/).includes("gp-pin");
+}
+var PIN_EDGES = ["gp-top", "gp-right", "gp-bottom", "gp-left"];
+var FLUSH_ART_MSG = "`.gp-flush` puts this image on the paper's edge, past the printer's safe area. Printers trim up to 0.125in there, so keep it for art that is meant to bleed off the page.";
+function checkFlushArt(token, env, line) {
+  if (token.type !== "image")
+    return;
+  const cls = token.attrGet && token.attrGet("class");
+  if (typeof cls !== "string")
+    return;
+  const classes = cls.split(/\s+/);
+  if (!classes.includes("gp-pin") || !classes.includes("gp-flush"))
+    return;
+  if (!classes.some((c) => PIN_EDGES.includes(c)))
+    return;
+  warn2(env, line, "flush_art", FLUSH_ART_MSG, "info");
+}
+function elementNameFor(token) {
+  switch (token.type) {
+    case "layout_chapter_open":
+      return "@chapter";
+    case "layout_spread_open":
+      return "@spread";
+    case "layout_page_open":
+      return "@page";
+    case "layout_section_open":
+      return "@section";
+    case "image":
+      return "an image";
+    case "heading_open":
+      return "a heading";
+    case "paragraph_open":
+      return "a paragraph";
+    case "link_open":
+      return "a link";
+    default:
+      return token.tag ? `a <${token.tag}>` : "an element";
+  }
+}
+function checkUnknownGpClasses(token, env, line) {
+  const cls = token.attrGet && token.attrGet("class");
+  if (typeof cls !== "string" || !cls)
+    return;
+  for (const c of cls.split(/\s+/)) {
+    if (!c.startsWith("gp-") || GP_CLASSES.has(c))
+      continue;
+    const suggestion = nearestGpClass(c);
+    const base = `Unknown class "${c}" on ${elementNameFor(token)}.`;
+    warn2(env, line, "unknown_gp_class", suggestion ? `${base} Did you mean "${suggestion}"?` : base);
+  }
+}
+function gpPinScope(md) {
+  const PIN_OUTSIDE_PAGE_MSG = "A .gp-pin element is not inside any @page or @spread, so it is pinned to the whole document instead of the page it sits on — it can print on a completely different sheet. Move it inside an @page or @spread block, or remove .gp-pin.";
+  md.core.ruler.push("gp_pin_scope_check", function(state) {
+    let depth = 0;
+    for (const token of state.tokens) {
+      if (token.type === "layout_page_open" || token.type === "layout_spread_open") {
+        depth += 1;
+      } else if (token.type === "layout_page_close" || token.type === "layout_spread_close") {
+        depth -= 1;
+      } else if (depth === 0) {
+        if (token.type === "inline" && token.children) {
+          for (const child of token.children) {
+            if (child.type === "image" && hasPinClass(child)) {
+              warn2(state.env, (token.map?.[0] ?? 0) + 1, "pin_outside_page", PIN_OUTSIDE_PAGE_MSG);
+            }
+          }
+        } else if (token.nesting === 1 && hasPinClass(token)) {
+          warn2(state.env, (token.map?.[0] ?? 0) + 1, "pin_outside_page", PIN_OUTSIDE_PAGE_MSG);
+        }
+      }
+      const line = (token.map?.[0] ?? 0) + 1;
+      checkUnknownGpClasses(token, state.env, line);
+      if (token.type === "inline" && token.children) {
+        for (const child of token.children) {
+          checkUnknownGpClasses(child, state.env, line);
+          checkFlushArt(child, state.env, line);
+        }
+      }
+    }
+  });
+}
+
+// src/lib/slug.ts
+function slugify(name, fallback = "") {
+  return name.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || fallback;
+}
+function prettify(slug) {
+  const spaced = slug.replace(/[-_]+/g, " ").trim();
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+
+// src/lib/markdown/block-names.ts
+var BLOCK_OPEN = /^layout_(chapter|spread|page|section|component)_open$/;
+var BLOCK_CLOSE = /^layout_(chapter|spread|page|section|component)_close$/;
+var FOLDED = {
+  ß: "ss",
+  æ: "ae",
+  œ: "oe",
+  ø: "o",
+  đ: "d",
+  ð: "d",
+  þ: "th",
+  ł: "l",
+  ı: "i"
+};
+function nameSlug(text) {
+  return slugify(text.replace(/['’]/g, "").replace(/[ßæœøđðþłı]/gi, (c) => FOLDED[c.toLowerCase()] ?? c));
+}
+function nameFromSrc(src) {
+  if (/^data:/i.test(src))
+    return "";
+  const path2 = src.split(/[?#]/, 1)[0] ?? "";
+  const base = path2.split(/[\\/]/).pop() ?? "";
+  let decoded = base;
+  try {
+    decoded = decodeURIComponent(base);
+  } catch {}
+  return nameSlug(decoded.replace(/\.[^.]*$/, ""));
+}
+function takeExplicitName(token) {
+  const data = token.attrGet("data-name");
+  const plain = token.attrGet("name");
+  if (plain !== null && token.attrs)
+    token.attrs = token.attrs.filter(([k]) => k !== "name");
+  if (data)
+    return data;
+  if (plain) {
+    token.attrSet("data-name", plain);
+    return plain;
+  }
+  return "";
+}
+function inlineText2(inline) {
+  if (!inline || inline.type !== "inline")
+    return "";
+  const parts = [];
+  for (const child of inline.children ?? []) {
+    if (child.type === "text" || child.type === "text_special" || child.type === "code_inline" || child.type === "image") {
+      parts.push(child.content);
+    } else if (child.type === "softbreak" || child.type === "hardbreak") {
+      parts.push(" ");
+    }
+  }
+  return parts.join("");
+}
+function claim(used, slug) {
+  let name = slug;
+  for (let n = 2;used.has(name); n++)
+    name = `${slug}-${n}`;
+  used.add(name);
+  return name;
+}
+function nameBlocksAndHeadings(tokens) {
+  const blocks = [];
+  const open = [];
+  const headings = [];
+  const headingSlugs = new Map;
+  for (let i = 0;i < tokens.length; i++) {
+    const tok = tokens[i];
+    const opened = BLOCK_OPEN.exec(tok.type);
+    if (opened) {
+      const block = { token: tok, type: opened[1], heading: "" };
+      blocks.push(block);
+      open.push(block);
+      continue;
+    }
+    const closed = BLOCK_CLOSE.exec(tok.type);
+    if (closed) {
+      for (let j = open.length - 1;j >= 0; j--) {
+        if (open[j].type === closed[1]) {
+          open.splice(j, 1);
+          break;
+        }
+      }
+      continue;
+    }
+    if (tok.type === "heading_open") {
+      const slug = nameSlug(inlineText2(tokens[i + 1]));
+      headings.push(tok);
+      headingSlugs.set(tok, slug);
+      const owner = open[open.length - 1];
+      if (owner && !owner.heading)
+        owner.heading = slug;
+    }
+  }
+  const usedBlocks = new Set;
+  const usedHeadings = new Set;
+  const unnamedBlocks = new Set;
+  for (const block of blocks) {
+    const explicit = block.token.attrGet("data-name");
+    if (explicit)
+      usedBlocks.add(explicit);
+    else
+      unnamedBlocks.add(block);
+  }
+  const unnamedHeadings = [];
+  for (const heading of headings) {
+    const explicit = takeExplicitName(heading);
+    if (explicit)
+      usedHeadings.add(explicit);
+    else
+      unnamedHeadings.push(heading);
+  }
+  let previousSection = null;
+  for (const block of blocks) {
+    const { token } = block;
+    if (block.type === "section") {
+      if (token.meta?.continued && previousSection) {
+        const inherited = previousSection.token.attrGet("data-name");
+        if (inherited)
+          token.attrSet("data-name", inherited);
+        previousSection = block;
+        continue;
+      }
+      previousSection = block;
+    }
+    if (!unnamedBlocks.has(block))
+      continue;
+    const slug = nameSlug(token.attrGet("data-label") ?? "") || block.heading;
+    if (slug)
+      token.attrSet("data-name", claim(usedBlocks, slug));
+  }
+  for (const heading of unnamedHeadings) {
+    const slug = headingSlugs.get(heading);
+    if (slug)
+      heading.attrSet("data-name", claim(usedHeadings, slug));
+  }
+}
+function gpBlockNames(md) {
+  md.core.ruler.push("gp_block_names", (state) => nameBlocksAndHeadings(state.tokens));
+}
+
+// src/lib/markdown/table-align.ts
+var ALIGN = /^text-align:(left|center|right)$/;
+function gpTableAlign(md) {
+  md.core.ruler.after("block", "gp_table_align", (state) => {
+    for (const token of state.tokens) {
+      if (token.type !== "th_open" && token.type !== "td_open")
+        continue;
+      const match = ALIGN.exec(token.attrGet("style") ?? "");
+      if (!match)
+        continue;
+      token.attrs = (token.attrs ?? []).filter(([key]) => key !== "style");
+      token.attrSet("data-align", match[1]);
+    }
+  });
+}
+var TABLE_ALIGN_CSS = `
+th[data-align="left"], td[data-align="left"] { text-align: left; }
+th[data-align="center"], td[data-align="center"] { text-align: center; }
+th[data-align="right"], td[data-align="right"] { text-align: right; }
+`;
+
+// src/lib/two-versions-markers.ts
+var YOUR_VERSION_LABEL = "your version";
+var ONLINE_VERSION_LABEL = "online version";
+var TWO_VERSIONS_OPEN = `<<<<<<< ${YOUR_VERSION_LABEL}`;
+var TWO_VERSIONS_SEPARATOR = "=======";
+var TWO_VERSIONS_CLOSE = `>>>>>>> ${ONLINE_VERSION_LABEL}`;
+
+// src/lib/markdown/two-versions.ts
+var TWO_VERSIONS_CSS = `
+.gp-two-versions {
+  margin: 1em 0;
+  border: 2px dashed #b7791f;
+  border-radius: 6px;
+  break-inside: avoid;
+}
+.gp-two-versions > .gp-version {
+  padding: 0.5em 0.9em;
+}
+.gp-two-versions > .gp-version + .gp-version {
+  border-top: 2px dashed #b7791f;
+}
+.gp-two-versions > .gp-version > .gp-version-text {
+  margin: 0;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  font-size: 0.85em;
+}
+.gp-two-versions > .gp-version::before {
+  content: attr(data-label);
+  display: block;
+  margin-bottom: 0.35em;
+  font-family: system-ui, sans-serif;
+  font-size: 0.7em;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: #b7791f;
+}
+`;
+function lineText(state, line) {
+  return state.src.slice(state.bMarks[line] + state.tShift[line], state.eMarks[line]);
+}
+var MARKER_LINE = /^@[a-z]/;
+function hasMarkerLine(state, from, to) {
+  for (let line = from;line < to; line++) {
+    if (MARKER_LINE.test(lineText(state, line)))
+      return true;
+  }
+  return false;
+}
+function pushVerbatim(state, from, to) {
+  const raw = state.getLines(from, to, 0, false);
+  const token = state.push("html_block", "", 0);
+  token.map = [from, to];
+  token.block = true;
+  token.content = `<pre class="gp-version-text">${state.md.utils.escapeHtml(raw)}</pre>
+`;
+}
+function pushVersion(state, which, label, from, to) {
+  const open = state.push("two_version_open", "div", 1);
+  open.attrSet("class", `gp-version gp-version-${which}`);
+  open.attrSet("data-label", label);
+  open.map = [from, to];
+  open.block = true;
+  if (hasMarkerLine(state, from, to)) {
+    pushVerbatim(state, from, to);
+  } else {
+    state.parentType = "container";
+    state.lineMax = to;
+    state.md.block.tokenize(state, from, to);
+  }
+  const close = state.push("two_version_close", "div", -1);
+  close.block = true;
+}
+function twoVersions(state, startLine, endLine, silent) {
+  if (state.sCount[startLine] - state.blkIndent >= 4)
+    return false;
+  if (state.src.charCodeAt(state.bMarks[startLine] + state.tShift[startLine]) !== 60)
+    return false;
+  if (lineText(state, startLine) !== TWO_VERSIONS_OPEN)
+    return false;
+  let separator = -1;
+  let closer = -1;
+  for (let line = startLine + 1;line < endLine; line++) {
+    const text = lineText(state, line);
+    if (separator < 0 && text === TWO_VERSIONS_SEPARATOR)
+      separator = line;
+    else if (text === TWO_VERSIONS_CLOSE) {
+      closer = line;
+      break;
+    } else if (text === TWO_VERSIONS_OPEN)
+      return false;
+  }
+  if (separator < 0 || closer < 0)
+    return false;
+  if (silent)
+    return true;
+  const oldParent = state.parentType;
+  const oldLineMax = state.lineMax;
+  const open = state.push("two_versions_open", "div", 1);
+  open.attrSet("class", "gp-two-versions");
+  open.map = [startLine, closer + 1];
+  open.block = true;
+  pushVersion(state, "yours", "Your version", startLine + 1, separator);
+  pushVersion(state, "online", "Online version", separator + 1, closer);
+  const close = state.push("two_versions_close", "div", -1);
+  close.block = true;
+  state.parentType = oldParent;
+  state.lineMax = oldLineMax;
+  state.line = closer + 1;
+  return true;
+}
+function gpTwoVersions(md) {
+  md.block.ruler.before("html_block", "two_versions", twoVersions, {
+    alt: ["paragraph", "reference", "blockquote", "list"]
+  });
+}
+
+// src/lib/markdown/renderer.ts
+import markdownItSourceMap from "markdown-it-source-map";
+import markdownItDeflist from "markdown-it-deflist";
+import markdownItMark from "markdown-it-mark";
+import markdownItSub from "markdown-it-sub";
+import markdownItSup from "markdown-it-sup";
+import markdownItAbbr from "markdown-it-abbr";
+
+// src/lib/markdown/gfm-alerts.ts
+var ALERT_LABELS = {
+  note: "Note",
+  tip: "Tip",
+  important: "Important",
+  warning: "Warning",
+  caution: "Caution"
+};
+var ALERT_MARKER = /^\[!(note|tip|important|warning|caution)\]\s*$/i;
+function isFiniteMap(map) {
+  return Array.isArray(map) && map.length === 2 && Number.isFinite(map[0]) && Number.isFinite(map[1]);
+}
+function blockToken(state, type, tag, nesting) {
+  const token = new state.Token(type, tag, nesting);
+  token.block = true;
+  return token;
+}
+var gfmAlertsRule = (state) => {
+  const tokens = state.tokens;
+  const newTokens = [];
+  for (let i = 0;i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (tok.type !== "blockquote_open") {
+      newTokens.push(tok);
+      continue;
+    }
+    let depth = 0;
+    let closeIdx = -1;
+    for (let j = i;j < tokens.length; j++) {
+      const jt = tokens[j];
+      if (jt.type === "blockquote_open")
+        depth++;
+      else if (jt.type === "blockquote_close") {
+        depth--;
+        if (depth === 0) {
+          closeIdx = j;
+          break;
+        }
+      }
+    }
+    const markerParaOpen = tokens[i + 1];
+    const markerInline = tokens[i + 2];
+    const markerParaClose = tokens[i + 3];
+    const hasMarkerParagraph = closeIdx !== -1 && markerParaOpen?.type === "paragraph_open" && markerInline?.type === "inline" && markerParaClose?.type === "paragraph_close";
+    if (!hasMarkerParagraph) {
+      newTokens.push(tok);
+      continue;
+    }
+    const content = markerInline.content;
+    const newlineIdx = content.indexOf(`
+`);
+    const firstLine = newlineIdx === -1 ? content : content.slice(0, newlineIdx);
+    const match = ALERT_MARKER.exec(firstLine);
+    if (!match) {
+      newTokens.push(tok);
+      continue;
+    }
+    const type = match[1].toLowerCase();
+    const label = ALERT_LABELS[type];
+    const markerLine = isFiniteMap(tok.map) ? tok.map[0] + 1 : undefined;
+    const alertOpen = blockToken(state, "gp_alert_open", "div", 1);
+    alertOpen.attrSet("class", `gp-alert gp-alert-${type}`);
+    if (markerLine !== undefined)
+      alertOpen.meta = { line: markerLine };
+    newTokens.push(alertOpen);
+    const titleOpen = blockToken(state, "gp_alert_title_open", "p", 1);
+    titleOpen.attrSet("class", "gp-alert-title");
+    if (markerLine !== undefined)
+      titleOpen.meta = { line: markerLine };
+    newTokens.push(titleOpen);
+    const titleInline = new state.Token("inline", "", 0);
+    titleInline.content = label;
+    titleInline.children = [];
+    newTokens.push(titleInline);
+    newTokens.push(blockToken(state, "gp_alert_title_close", "p", -1));
+    const rest = newlineIdx === -1 ? "" : content.slice(newlineIdx + 1);
+    if (rest.trim() !== "") {
+      markerInline.content = rest;
+      if (isFiniteMap(markerParaOpen.map)) {
+        markerParaOpen.map = [markerParaOpen.map[0] + 1, markerParaOpen.map[1]];
+      }
+      newTokens.push(markerParaOpen, markerInline, markerParaClose);
+    }
+    for (let j = i + 4;j < closeIdx; j++) {
+      newTokens.push(tokens[j]);
+    }
+    newTokens.push(blockToken(state, "gp_alert_close", "div", -1));
+    i = closeIdx;
+  }
+  state.tokens = newTokens;
+};
+function gfmAlerts(md) {
+  md.core.ruler.after("block", "gp_gfm_alerts", gfmAlertsRule);
+}
+
+// src/lib/markdown/images.ts
+var isSrcsetSpace = (char) => char === "\t" || char === `
+` || char === "\f" || char === "\r" || char === " ";
+function parseSrcsetUrlCandidates(input) {
+  const candidates = [];
+  let position = 0;
+  while (position < input.length) {
+    while (position < input.length && (isSrcsetSpace(input[position]) || input[position] === ",")) {
+      position++;
+    }
+    if (position >= input.length)
+      break;
+    const urlStart = position;
+    while (position < input.length && !isSrcsetSpace(input[position]))
+      position++;
+    let urlEnd = position;
+    if (input[urlEnd - 1] === ",") {
+      while (urlEnd > urlStart && input[urlEnd - 1] === ",")
+        urlEnd--;
+      if (urlEnd > urlStart) {
+        candidates.push({
+          url: input.slice(urlStart, urlEnd),
+          start: urlStart,
+          end: urlEnd
+        });
+      }
+      continue;
+    }
+    let parenDepth = 0;
+    while (position < input.length) {
+      const char = input[position];
+      if (char === "(")
+        parenDepth++;
+      else if (char === ")" && parenDepth > 0)
+        parenDepth--;
+      else if (char === "," && parenDepth === 0) {
+        position++;
+        break;
+      }
+      position++;
+    }
+    if (urlEnd > urlStart) {
+      candidates.push({
+        url: input.slice(urlStart, urlEnd),
+        start: urlStart,
+        end: urlEnd
+      });
+    }
+  }
+  return candidates;
+}
+function registerImageRule(md) {
+  const defaultRender = md.renderer.rules.image ?? ((tokens, idx, options, _env, self) => self.renderToken(tokens, idx, options));
+  md.renderer.rules.image = (tokens, idx, options, env, self) => {
+    const token = tokens[idx];
+    for (const child of token.children ?? []) {
+      if (child.type === "text_special" || child.type === "code_inline")
+        child.type = "text";
+    }
+    const srcIdx = token.attrIndex("src");
+    if (srcIdx >= 0 && token.attrs) {
+      const src = token.attrs[srcIdx][1];
+      if (src) {
+        const explicit = takeExplicitName(token);
+        const named = explicit || nameFromSrc(src);
+        if (named)
+          token.attrSet("data-name", named);
+        const bucket = env ?? {};
+        (bucket.imageRefs ??= []).push(src);
+        const cls = token.attrGet("class");
+        if (cls && cls.split(/\s+/).includes("gp-shape")) {
+          const cssUrl = src.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+          const decl = `--gp-shape:url("${cssUrl}")`;
+          const existing = token.attrGet("style");
+          token.attrSet("style", existing ? `${decl}; ${existing}` : decl);
+        }
+      }
+    }
+    return defaultRender(tokens, idx, options, env, self);
+  };
+}
+function collectHtmlImageRefs(html) {
+  const refs = [];
+  const tags = [];
+  const collectTags = (active) => {
+    for (const match of active.matchAll(/<(?:"[^"]*"|'[^']*'|[^'">])*>/g)) {
+      if (/^<(?:img|source)\b/i.test(match[0]))
+        tags.push(match[0]);
+    }
+  };
+  const protectedRegion = /<!--[\s\S]*?-->|<(script|style|pre|code|textarea)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+  let last = 0;
+  for (const match of html.matchAll(protectedRegion)) {
+    const index = match.index ?? 0;
+    collectTags(html.slice(last, index));
+    last = index + match[0].length;
+  }
+  collectTags(html.slice(last));
+  const attr = (tag, name) => {
+    const match = new RegExp(`[\\t\\n\\f\\r ]${name}[\\t\\n\\f\\r ]*=[\\t\\n\\f\\r ]*(?:"([^"]*)"|'([^']*)'|([^\\t\\n\\f\\r >]+))`, "i").exec(tag);
+    return match?.[1] ?? match?.[2] ?? match?.[3];
+  };
+  for (const tag of tags) {
+    if (!/^<img\b/i.test(tag))
+      continue;
+    const src = attr(tag, "src");
+    if (src)
+      refs.push(src);
+  }
+  for (const tag of tags) {
+    const list = attr(tag, "srcset") ?? "";
+    refs.push(...parseSrcsetUrlCandidates(list).map((candidate) => candidate.url));
+  }
+  return refs;
+}
+
+// src/lib/markdown/source-range.ts
+var SOURCE_RANGE_ATTR = "data-source-range";
+var SOURCE_CHAPTER_ATTR = "data-chapter-src";
+var SELF_CLOSING_BLOCK_TYPES = new Set([
+  "fence",
+  "hr",
+  "html_block",
+  "layout_page_break",
+  "layout_column_break"
+]);
+function isFiniteRangeTuple(value) {
+  return Array.isArray(value) && value.length === 2 && Number.isFinite(value[0]) && Number.isFinite(value[1]);
+}
+function resolveRange(token) {
+  if (isFiniteRangeTuple(token.map)) {
+    return [token.map[0], token.map[1]];
+  }
+  const meta = token.meta;
+  const line = meta?.line;
+  if (typeof line === "number" && Number.isFinite(line)) {
+    return [line - 1, line];
+  }
+  return null;
+}
+function isAnnotationTarget(token) {
+  if (token.nesting === 1)
+    return true;
+  return token.nesting === 0 && SELF_CLOSING_BLOCK_TYPES.has(token.type);
+}
+function annotateToken(token, chapter) {
+  if (!isAnnotationTarget(token))
+    return;
+  const range = resolveRange(token);
+  if (!range)
+    return;
+  token.attrSet(SOURCE_RANGE_ATTR, `${range[0]}:${range[1]}`);
+  if (chapter)
+    token.attrSet(SOURCE_CHAPTER_ATTR, chapter);
+}
+var sourceRangeRule = (state) => {
+  const chapter = typeof state.env?.sourceChapter === "string" ? state.env.sourceChapter : null;
+  for (const token of state.tokens) {
+    annotateToken(token, chapter);
+  }
+};
+
+// src/lib/markdown/inline-source.ts
+var SOURCE_TOKEN_ATTR = "data-gp-source-token";
+var SOURCE_OCCURRENCE_ATTR = "data-gp-source-occurrence";
+var RESERVED_ATTRS = new Set([SOURCE_TOKEN_ATTR, SOURCE_OCCURRENCE_ATTR]);
+function isHtmlSpace(char) {
+  return char === " " || char === "\t" || char === `
+` || char === "\r" || char === "\f";
+}
+function stripReservedAttrsFromTag(html) {
+  let out = "";
+  let inTag = false;
+  let quote = "";
+  for (let i = 0;i < html.length; ) {
+    const char = html[i];
+    if (!inTag) {
+      out += char;
+      if (char === "<")
+        inTag = true;
+      i++;
+      continue;
+    }
+    if (quote) {
+      out += char;
+      if (char === quote)
+        quote = "";
+      i++;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      out += char;
+      i++;
+      continue;
+    }
+    if (char === ">") {
+      inTag = false;
+      out += char;
+      i++;
+      continue;
+    }
+    if (!isHtmlSpace(char)) {
+      out += char;
+      i++;
+      continue;
+    }
+    let nameStart = i;
+    while (isHtmlSpace(html[nameStart]))
+      nameStart++;
+    let nameEnd = nameStart;
+    while (nameEnd < html.length && !isHtmlSpace(html[nameEnd]) && html[nameEnd] !== "=" && html[nameEnd] !== "/" && html[nameEnd] !== ">")
+      nameEnd++;
+    const name = html.slice(nameStart, nameEnd).toLowerCase();
+    if (!RESERVED_ATTRS.has(name)) {
+      out += html.slice(i, nameStart);
+      i = nameStart;
+      continue;
+    }
+    i = nameEnd;
+    while (isHtmlSpace(html[i]))
+      i++;
+    if (html[i] !== "=")
+      continue;
+    i++;
+    while (isHtmlSpace(html[i]))
+      i++;
+    const valueQuote = html[i];
+    if (valueQuote === '"' || valueQuote === "'") {
+      for (i++;i < html.length && html[i] !== valueQuote; i++) {}
+      if (html[i] === valueQuote)
+        i++;
+    } else {
+      while (i < html.length && !isHtmlSpace(html[i]) && html[i] !== ">")
+        i++;
+    }
+  }
+  return out;
+}
+function tagEnd(html, start) {
+  let quote = "";
+  for (let i = start + 1;i < html.length; i++) {
+    const char = html[i];
+    if (quote) {
+      if (char === quote)
+        quote = "";
+    } else if (char === '"' || char === "'")
+      quote = char;
+    else if (char === ">")
+      return i + 1;
+  }
+  return html.length;
+}
+function tagIdentity(tag) {
+  let i = 1;
+  while (isHtmlSpace(tag[i]))
+    i++;
+  const closing = tag[i] === "/";
+  if (closing) {
+    i++;
+    while (isHtmlSpace(tag[i]))
+      i++;
+  }
+  const start = i;
+  while (i < tag.length) {
+    const char = tag[i].toLowerCase();
+    if (char >= "a" && char <= "z" || char >= "0" && char <= "9" || char === "-")
+      i++;
+    else
+      break;
+  }
+  return i > start ? { name: tag.slice(start, i).toLowerCase(), closing } : null;
+}
+function findProtectedClose(html, tag, from) {
+  const needle = `</${tag}`;
+  for (let at = html.indexOf(needle, from);at >= 0; at = html.indexOf(needle, at + needle.length)) {
+    const boundary = html[at + needle.length];
+    if (boundary === ">" || boundary === "/" || isHtmlSpace(boundary))
+      return at;
+  }
+  return -1;
+}
+function stripReservedRawHtmlAttrs(html, initialProtectedTag = "") {
+  const protectedTags = new Set([
+    "script",
+    "style",
+    "textarea",
+    "title",
+    "xmp",
+    "iframe",
+    "noembed",
+    "noframes",
+    "noscript",
+    "plaintext"
+  ]);
+  const lower = html.toLowerCase();
+  let out = "";
+  let i = 0;
+  let protectedTag = initialProtectedTag;
+  while (i < html.length) {
+    if (protectedTag) {
+      if (protectedTag === "plaintext")
+        return { html: out + html.slice(i), protectedTag };
+      const closeAt = findProtectedClose(lower, protectedTag, i);
+      if (closeAt < 0)
+        return { html: out + html.slice(i), protectedTag };
+      out += html.slice(i, closeAt);
+      i = closeAt;
+      protectedTag = "";
+      continue;
+    }
+    if (html.startsWith("<!--", i)) {
+      const closeAt = html.indexOf("-->", i + 4);
+      const end2 = closeAt < 0 ? html.length : closeAt + 3;
+      out += html.slice(i, end2);
+      i = end2;
+      continue;
+    }
+    if (html[i] !== "<") {
+      out += html[i++];
+      continue;
+    }
+    const end = tagEnd(html, i);
+    const tag = html.slice(i, end);
+    const identity = tagIdentity(tag);
+    if (!identity) {
+      out += tag;
+    } else if (!identity.closing && (identity.name === "img" || identity.name === "a")) {
+      out += stripReservedAttrsFromTag(tag);
+    } else {
+      out += tag;
+      if (!identity.closing && protectedTags.has(identity.name)) {
+        protectedTag = identity.name;
+      }
+    }
+    i = end;
+  }
+  return { html: out, protectedTag };
+}
+function occurrenceAt(source, token, target) {
+  let occurrence = 0;
+  let from = 0;
+  while (from < target) {
+    const found = source.indexOf(token, from);
+    if (found < 0 || found >= target)
+      break;
+    occurrence++;
+    from = found + token.length;
+  }
+  return occurrence;
+}
+function registerInlineSourceMetadata(md) {
+  md.core.ruler.push("inline_source_raw_html", (state) => {
+    let protectedTag = "";
+    for (const block of state.tokens) {
+      if (block.type === "html_block") {
+        const sanitized = stripReservedRawHtmlAttrs(block.content, protectedTag);
+        block.content = sanitized.html;
+        protectedTag = sanitized.protectedTag;
+        continue;
+      }
+      if (!block.children)
+        continue;
+      for (const token of block.children) {
+        if (token.type !== "html_inline")
+          continue;
+        const sanitized = stripReservedRawHtmlAttrs(token.content, protectedTag);
+        token.content = sanitized.html;
+        protectedTag = sanitized.protectedTag;
+      }
+    }
+  });
+  const ruler = md.inline.ruler;
+  for (const [ruleName, tokenType] of [["image", "image"], ["link", "link_open"]]) {
+    const entry = ruler.__rules__.find((rule) => rule.name === ruleName);
+    if (!entry)
+      continue;
+    const original = entry.fn;
+    ruler.at(ruleName, (state, silent) => {
+      const sourceStart = state.pos;
+      const tokenStart = state.tokens.length;
+      const matched = original(state, silent);
+      if (!matched || silent)
+        return matched;
+      const token = state.tokens.slice(tokenStart).find((candidate) => candidate.type === tokenType);
+      if (!token)
+        return matched;
+      const sourceToken = state.src.slice(sourceStart, state.pos);
+      if (sourceToken.includes(`
+`) || sourceToken.includes("\r"))
+        return matched;
+      token.meta ??= {};
+      token.meta.gpInlineSource = {
+        token: sourceToken,
+        occurrence: occurrenceAt(state.src, sourceToken, sourceStart)
+      };
+      return matched;
+    });
+    const originalRender = md.renderer.rules[tokenType];
+    md.renderer.rules[tokenType] = (tokens, index, options, env, renderer) => {
+      const token = tokens[index];
+      if (token.attrs) {
+        token.attrs = token.attrs.filter(([name]) => !RESERVED_ATTRS.has(name.toLowerCase()));
+      }
+      const source = token.meta?.gpInlineSource;
+      if (source) {
+        token.attrSet(SOURCE_TOKEN_ATTR, source.token);
+        token.attrSet(SOURCE_OCCURRENCE_ATTR, String(source.occurrence));
+      }
+      return originalRender ? originalRender(tokens, index, options, env, renderer) : renderer.renderToken(tokens, index, options);
+    };
+  }
+}
+
+// src/lib/markdown/renderer.ts
+function hasDefaultExport(plugin2) {
+  return !!plugin2 && typeof plugin2 === "object" && "default" in plugin2;
+}
+function unwrapPlugin(plugin2) {
+  return hasDefaultExport(plugin2) ? plugin2.default : plugin2;
+}
+var BUILTIN_OPTIONAL_PLUGINS = {
+  "markdown-it-mark": unwrapPlugin(markdownItMark),
+  "markdown-it-sub": unwrapPlugin(markdownItSub),
+  "markdown-it-sup": unwrapPlugin(markdownItSup),
+  "markdown-it-abbr": unwrapPlugin(markdownItAbbr),
+  "gutterpress-gfm-alerts": gfmAlerts
+};
+function createMarkdownRenderer(customPlugins) {
+  const md = new MarkdownIt({
+    html: true,
+    linkify: true,
+    typographer: true
+  });
+  md.use(unwrapPlugin(markdownItAttrs));
+  md.use(unwrapPlugin(markdownItFootnote));
+  md.use(unwrapPlugin(markdownItDeflist));
+  md.use(unwrapPlugin(markdownItSourceMap));
+  const declaredMarkerSources = (customPlugins ?? []).filter((p) => !!p.markers).map((p) => ({ pluginName: p.name, markers: p.markers }));
+  const declaredMarkers = buildDeclaredMarkerRegistry(declaredMarkerSources);
+  md.use(plugin, { declaredMarkers });
+  md.use(gpPinScope);
+  md.use(gpBlockNames);
+  md.use(gpTableAlign);
+  md.use(gpTwoVersions);
+  registerImageRule(md);
+  if (customPlugins && customPlugins.length > 0) {
+    applyPlugins(md, customPlugins);
+  }
+  registerInlineSourceMetadata(md);
+  md.core.ruler.push("source_range", sourceRangeRule);
+  return md;
+}
+function applyPlugins(md, plugins) {
+  for (const { name, plugin: plugin2, options, metadata } of plugins) {
+    try {
+      md.use(plugin2, options);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to apply plugin "${name}": ${errorMsg}`);
+    }
+    if (metadata?.name) {
+      debug(`Loaded plugin: ${metadata.name} v${metadata.version ?? "?"}`);
+    } else {
+      debug(`Loaded plugin: ${name}`);
+    }
+  }
+}
+function collectPluginCss(plugins) {
+  return plugins.map((p) => p.css).filter((css) => typeof css === "string" && css.length > 0).join(`
+
+`);
+}
+function collectPluginStylePaths(plugins) {
+  return plugins.flatMap((p) => p.styles ?? []);
+}
+function collectPluginStyleGroups(plugins) {
+  const taken = new Set;
+  const groups = [];
+  for (const p of plugins) {
+    const paths = p.styles ?? [];
+    const css = typeof p.css === "string" && p.css.length > 0 ? p.css : undefined;
+    if (paths.length === 0 && !css)
+      continue;
+    const base = `ext.${layerSlug(p.name)}`;
+    let layer = base;
+    for (let n = 2;taken.has(layer); n++)
+      layer = `${base}-${n}`;
+    taken.add(layer);
+    groups.push({ name: p.name, layer, paths, ...css ? { css } : {} });
+  }
+  return groups;
+}
+function layerSlug(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  return /^[a-z]/.test(slug) ? slug : `x${slug}`;
+}
+// src/lib/markdown/plugins.ts
+var vendoredRootsOpened = new Set;
+var bunVendoredResolverInstalled = false;
+function isInsideDir(candidate, root) {
+  return candidate === root || candidate.startsWith(root.endsWith(sep) ? root : root + sep);
+}
+function resolveBareSpecifierSync(specifier, fromDir, stopRoot, condition) {
+  const parts = specifier.split("/");
+  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  const subpath = specifier.slice(name.length).replace(/^\//, "");
+  for (let dir = fromDir;isInsideDir(dir, stopRoot); dir = dirname(dir)) {
+    const packageDir = join(dir, "node_modules", ...name.split("/"));
+    const packageJson = join(packageDir, "package.json");
+    if (!existsSync2(packageJson)) {
+      if (dir === stopRoot)
+        break;
+      continue;
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync(packageJson, "utf8"));
+    } catch {
+      return null;
+    }
+    for (const target of packageResolutionTargets(manifest, subpath, condition)) {
+      const rel = safePackageTarget(target.target);
+      if (!rel)
+        continue;
+      const base = resolve2(packageDir, ...rel.split("/"));
+      if (!isInsideDir(base, packageDir))
+        continue;
+      const candidates = target.exact ? [base] : [base, `${base}.mjs`, `${base}.js`, `${base}.cjs`, `${base}.json`, join(base, "index.mjs"), join(base, "index.js"), join(base, "index.cjs")];
+      for (const candidate of candidates) {
+        try {
+          if (statSync(candidate).isFile())
+            return candidate;
+        } catch {}
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function installBunVendoredResolver() {
+  if (bunVendoredResolverInstalled)
+    return;
+  bunVendoredResolverInstalled = true;
+  const bun = globalThis.Bun;
+  if (typeof bun?.plugin !== "function")
+    return;
+  bun.plugin({
+    name: "gutterpress-vendored-plugins",
+    setup(build) {
+      build.onResolve({ filter: /^[^./]/ }, (args) => {
+        if (!args.importer || isAbsolute(args.path) || /^[a-z]+:/i.test(args.path) || isBuiltin(args.path)) {
+          return;
+        }
+        let root;
+        for (const opened of vendoredRootsOpened) {
+          if (isInsideDir(args.importer, opened)) {
+            root = opened;
+            break;
+          }
+        }
+        if (!root)
+          return;
+        const resolved = resolveBareSpecifierSync(args.path, dirname(args.importer), root, args.kind === "require-call" || args.kind === "require-resolve" ? "require" : "import");
+        return resolved ? { path: resolved } : undefined;
+      });
+    }
+  });
+}
+async function vendoredInstallRoot(packageName, baseDir, version) {
+  if (!version || !isValidNpmPackageName(packageName) || !isExactNpmVersion(version))
+    return null;
+  return resolveVendoredPluginInstallRoot(baseDir, packageName, version);
+}
+async function importVendoredEntry(installRoot, packageDir, spec) {
+  let entry;
+  try {
+    entry = await resolvePackageEntry(packageDir);
+  } catch (cause) {
+    throw new Error(`the downloaded copy of ${spec} under plugins/npm/ is incomplete ` + `(${cause instanceof Error ? cause.message : String(cause)}). ` + `Reinstall it with \`gutterpress ext add ${spec}\`.`, { cause });
+  }
+  const entryPath = join(packageDir, ...entry.split("/"));
+  vendoredRootsOpened.add(installRoot);
+  installBunVendoredResolver();
+  return { module: await import(pathToFileURL(entryPath).href), entryPath };
+}
+async function loadNpmPackage(packageName, baseDir, version) {
+  const installRoot = await vendoredInstallRoot(packageName, baseDir, version);
+  if (installRoot) {
+    const packageDir = vendoredNpmPluginPackageDir(installRoot, packageName);
+    const { module, entryPath } = await importVendoredEntry(installRoot, packageDir, `${packageName}@${version}`);
+    return { module, moduleDir: dirname(entryPath), packageDir, entryPath };
+  }
+  try {
+    const packageDir = join(baseDir, "node_modules", ...packageName.split("/"));
+    const packagePath = join(packageDir, ...(await resolvePackageEntry(packageDir)).split("/"));
+    return {
+      module: await import(pathToFileURL(packagePath).href),
+      moduleDir: dirname(packagePath),
+      packageDir,
+      entryPath: packagePath
+    };
+  } catch {}
+  try {
+    return { module: await import(packageName), moduleDir: null, packageDir: null, entryPath: null };
+  } catch {}
+  const looksLikeJsFilename = /\.(m?js|cjs)$/i.test(packageName);
+  const suggestedPath = looksLikeJsFilename ? `./${packageName}` : `./plugins/${packageName}.js`;
+  if (!looksLikeJsFilename && (!version || !isExactNpmVersion(version))) {
+    throw new Error(`Extension "${packageName}${version ? `@${version}` : ""}" is not pinned to an exact version, so it can't be downloaded automatically. Run \`gutterpress ext add ${packageName}\` (or use Book settings > Features in the desktop app) to download it and pin its version in your manifest.`);
+  }
+  throw new Error(`Extension "${packageName}" not found. Install it with \`gutterpress ext add ${version ? `${packageName}@${version}` : packageName}\` (or Book settings > Features > Advanced in the desktop app),
+or reference a local file under \`extensions:\`:
+  extensions:
+    - ${suggestedPath}`);
+}
+function validateStylesExport(value, pluginRef) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value) || !value.every((s) => typeof s === "string")) {
+    throw new Error(`Plugin "${pluginRef}" exports \`styles\` that is not an array of strings.`);
+  }
+  return value.length > 0 ? value : undefined;
+}
+function validateMarkersExport(value, pluginRef) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`Plugin "${pluginRef}" exports \`markers\` that is not a plain object.`);
+  }
+  const table = value;
+  return Object.keys(table).length > 0 ? table : undefined;
+}
+function extractPluginExports(pluginModule, pluginRef, exportName) {
+  const mod = pluginModule !== null && (typeof pluginModule === "object" || typeof pluginModule === "function") ? pluginModule : {};
+  let plugin2;
+  let metadata = mod.metadata;
+  let css = mod.css;
+  let styles = validateStylesExport(mod.styles, pluginRef);
+  let markers = validateMarkersExport(mod.markers, pluginRef);
+  if (exportName && typeof mod[exportName] === "function") {
+    plugin2 = mod[exportName];
+  } else if (exportName) {
+    const available = Object.entries(mod).filter(([, value]) => typeof value === "function").map(([name]) => name).sort();
+    throw new Error(`Plugin "${pluginRef}" does not export a plugin function named "${exportName}".` + (available.length > 0 ? ` Available function exports: ${available.join(", ")}.` : ""));
+  } else if (typeof mod.default === "function") {
+    plugin2 = mod.default;
+  } else if (typeof pluginModule === "function") {
+    plugin2 = pluginModule;
+  } else if (typeof mod.default === "object" && mod.default !== null && typeof mod.default.default === "function") {
+    const inner = mod.default;
+    plugin2 = inner.default;
+    metadata = inner.metadata ?? metadata;
+    css = inner.css ?? css;
+    styles = validateStylesExport(inner.styles, pluginRef) ?? styles;
+    markers = validateMarkersExport(inner.markers, pluginRef) ?? markers;
+  }
+  if (typeof plugin2 !== "function") {
+    throw new Error(`Plugin "${pluginRef}" does not export a valid plugin function. Expected \`export default function (md, options) { ... }\` or CommonJS \`module.exports = function (md, options) { ... }\`.`);
+  }
+  return { plugin: plugin2, metadata, css, styles, markers };
+}
+var pathPluginCache = new Map;
+function __resetPathPluginCacheForTests() {
+  pathPluginCache.clear();
+}
+var liveShadowPaths = new Set;
+var exitCleanupRegistered = false;
+function ensureExitCleanupRegistered() {
+  if (exitCleanupRegistered)
+    return;
+  exitCleanupRegistered = true;
+  process.on("exit", () => {
+    for (const shadowPath of liveShadowPaths) {
+      try {
+        unlinkSync(shadowPath);
+      } catch {}
+    }
+  });
+}
+function shadowPathFor(pluginPath, mtimeMs) {
+  const ext = extname(pluginPath);
+  const stem = basename(pluginPath, ext);
+  const token = String(mtimeMs).replace(/\./g, "-");
+  return join(dirname(pluginPath), `.${stem}.gutterpress-reload-${process.pid}-${token}${ext}`);
+}
+async function loadCachedPathPluginModule(pluginPath) {
+  const mtimeMs = statSync(pluginPath).mtimeMs;
+  const cached = pathPluginCache.get(pluginPath);
+  if (cached && cached.mtimeMs === mtimeMs) {
+    return cached.module;
+  }
+  const shadowPath = shadowPathFor(pluginPath, mtimeMs);
+  let pluginModule;
+  let shadowActive = false;
+  try {
+    await link(pluginPath, shadowPath);
+    shadowActive = true;
+    ensureExitCleanupRegistered();
+    liveShadowPaths.add(shadowPath);
+    pluginModule = await import(pathToFileURL(shadowPath).href);
+  } catch (error) {
+    if (shadowActive) {
+      liveShadowPaths.delete(shadowPath);
+      await unlink(shadowPath).catch(() => {});
+      throw error;
+    }
+    pluginModule = await import(pathToFileURL(pluginPath).href);
+  }
+  const previousShadow = cached?.shadowPath;
+  pathPluginCache.set(pluginPath, {
+    mtimeMs,
+    module: pluginModule,
+    shadowPath: shadowActive ? shadowPath : null
+  });
+  if (previousShadow) {
+    liveShadowPaths.delete(previousShadow);
+    await unlink(previousShadow).catch(() => {});
+  }
+  return pluginModule;
+}
+function resolvePluginStyles(rawStyles, moduleDir, pluginRef) {
+  if (!rawStyles || rawStyles.length === 0)
+    return;
+  if (!moduleDir) {
+    throw new Error(`Plugin "${pluginRef}" exports \`styles\` but its module directory could not be resolved.`);
+  }
+  return resolveDeclaredStyles(rawStyles, moduleDir, `Plugin "${pluginRef}"`);
+}
+function noopPlugin() {}
+function extensionMetadata(meta) {
+  if (!meta.name && !meta.description && !meta.author)
+    return;
+  return {
+    ...meta.name ? { name: meta.name } : {},
+    ...meta.description ? { description: meta.description } : {},
+    ...meta.author ? { author: meta.author } : {}
+  };
+}
+function staleManifestHint(dir) {
+  const stale = ["gutterpress.json", "theme.json"].find((name) => existsSync2(join(dir, name)));
+  if (!stale)
+    return "";
+  return `
+
+This folder still has a ${stale}. Gutterpress no longer reads it — ` + `describe the extension in package.json instead:
+  {
+    "name": "my-extension",
+    "description": "What it does",
+    "author": "You",
+    "main": "plugin.js",
+    "gutterpress": { "styles": ["theme.css"] }
+  }
+(\`main\` only if the package carries a markdown-it plugin; \`gutterpress.styles\` only if it carries stylesheets.)`;
+}
+async function loadExtensionFromDir(extensionDir, config, pluginRef) {
+  const meta = await readExtensionMeta(extensionDir);
+  assertExtensionContained(meta);
+  assertPublishOnly(meta, pluginRef);
+  assertSupportsThisGutterpress(meta, pluginRef);
+  const resolved = resolveExtension(extensionDir, meta, `Plugin "${pluginRef}"`);
+  const extensionStyles = resolved.styles ?? [];
+  const name = config.name ?? meta.name ?? pluginRef;
+  if (!resolved.markdown && extensionStyles.length === 0 && !meta.publish) {
+    throw new Error(`Extension folder "${pluginRef}" declares no markdown-it plugin (\`main\`) and no ` + "`gutterpress.styles` in its package.json — there is nothing to load. Point " + "`path` at a JS file directly for a plain plugin, or describe the package in package.json." + staleManifestHint(extensionDir));
+  }
+  if (!resolved.markdown) {
+    return {
+      name,
+      plugin: noopPlugin,
+      ...extensionMetadata(meta) ? { metadata: extensionMetadata(meta) } : {},
+      ...extensionStyles.length > 0 ? { styles: extensionStyles } : {},
+      options: config.options
+    };
+  }
+  const pluginModule = await loadCachedPathPluginModule(resolved.markdown);
+  const { plugin: plugin2, metadata, css, styles: rawStyles, markers } = extractPluginExports(pluginModule, pluginRef, config.export);
+  const ownStyles = resolvePluginStyles(rawStyles, dirname(resolved.markdown), pluginRef);
+  const styles = [...extensionStyles, ...ownStyles ?? []];
+  return {
+    name,
+    plugin: plugin2,
+    metadata: metadata ?? extensionMetadata(meta),
+    css,
+    ...styles.length > 0 ? { styles } : {},
+    ...markers ? { markers } : {},
+    options: config.options
+  };
+}
+async function loadPlugin(config, baseDir) {
+  const pluginRef = config.use;
+  let pluginModule;
+  let pluginName;
+  let moduleDir = null;
+  let packageMeta;
+  let packageStyles = [];
+  if (!config.path && !config.name) {
+    throw new Error("Plugin manifest entry must specify either `path` or `name`. Got an empty plugin config.");
+  }
+  if (!config.path && !config.version && config.name && BUILTIN_OPTIONAL_PLUGINS[config.name]) {
+    return {
+      name: config.name,
+      plugin: BUILTIN_OPTIONAL_PLUGINS[config.name],
+      options: config.options
+    };
+  }
+  if (config.path) {
+    const candidatePath = resolve2(baseDir, config.path);
+    if (existsSync2(candidatePath) && statSync(candidatePath).isDirectory()) {
+      try {
+        return await loadExtensionFromDir(candidatePath, config, pluginRef);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load plugin "${pluginRef}": ${errorMsg}`);
+      }
+    }
+  }
+  try {
+    if (config.path) {
+      const pluginPath = resolve2(baseDir, config.path);
+      if (!existsSync2(pluginPath)) {
+        throw new Error(`Plugin file not found: ${pluginPath} (resolved from manifest entry path="${config.path}")`);
+      }
+      pluginModule = await loadCachedPathPluginModule(pluginPath);
+      pluginName = config.name ?? config.path;
+      moduleDir = dirname(pluginPath);
+    } else {
+      const installRoot = await vendoredInstallRoot(config.name, baseDir, config.version);
+      if (installRoot) {
+        const meta = await readExtensionMeta(vendoredNpmPluginPackageDir(installRoot, config.name));
+        if (meta.publish) {
+          assertPublishOnly(meta, pluginRef);
+          assertSupportsThisGutterpress(meta, pluginRef);
+          return {
+            name: config.name,
+            plugin: noopPlugin,
+            ...extensionMetadata(meta) ? { metadata: extensionMetadata(meta) } : {},
+            options: config.options
+          };
+        }
+      }
+      const loaded = await loadNpmPackage(config.name, baseDir, config.version);
+      pluginModule = loaded.module;
+      moduleDir = loaded.moduleDir;
+      pluginName = config.name;
+      if (loaded.packageDir) {
+        const meta = await readExtensionMeta(loaded.packageDir);
+        assertExtensionContained(meta);
+        assertSupportsThisGutterpress(meta, pluginRef);
+        const resolved = resolveExtension(loaded.packageDir, { ...meta, main: undefined }, `Plugin "${pluginRef}"`);
+        if (resolved.markdown && loaded.entryPath && resolve2(resolved.markdown) !== resolve2(loaded.entryPath)) {
+          throw new Error(`its package.json declares gutterpress.markdown "${meta.markdown}" but the package entry is "${relative(loaded.packageDir, loaded.entryPath)}" — an npm extension's ` + "markdown-it plugin is its package entry, so declare that file or drop the field.");
+        }
+        packageMeta = meta;
+        packageStyles = resolved.styles ?? [];
+      }
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load plugin "${pluginRef}": ${errorMsg}`);
+  }
+  const { plugin: plugin2, metadata, css, styles: rawStyles, markers } = extractPluginExports(pluginModule, pluginRef, config.export);
+  const ownStyles = resolvePluginStyles(rawStyles, moduleDir, pluginRef);
+  const styles = packageStyles.length > 0 ? [...packageStyles, ...ownStyles ?? []] : ownStyles;
+  return {
+    name: pluginName,
+    plugin: plugin2,
+    metadata: metadata ?? (packageMeta ? extensionMetadata(packageMeta) : undefined),
+    css,
+    styles,
+    markers,
+    options: config.options
+  };
+}
+async function loadPublishFunction({ dir, installRoot, ref }) {
+  const meta = await readExtensionMeta(dir);
+  assertExtensionContained(meta);
+  assertPublishOnly(meta, ref);
+  assertSupportsThisGutterpress(meta, ref);
+  let mod;
+  if (installRoot) {
+    mod = (await importVendoredEntry(installRoot, dir, ref)).module;
+  } else {
+    if (!meta.main)
+      throw new Error(`Publishing plugin "${ref}" declares no \`main\` in its package.json.`);
+    const entry = resolve2(dir, meta.main);
+    if (!existsSync2(entry)) {
+      throw new Error(`Publishing plugin "${ref}" declares main "${meta.main}" but no file exists at ${entry}.`);
+    }
+    mod = await loadCachedPathPluginModule(entry);
+  }
+  const moduleExports = mod ?? {};
+  const publish = moduleExports.publish ?? moduleExports.default?.publish;
+  if (typeof publish !== "function") {
+    throw new Error(`"${ref}" does not export a \`publish\` function.`);
+  }
+  return publish;
+}
+async function loadPlugins(configs, baseDir, onError) {
+  const plugins = [];
+  for (const config of configs) {
+    if (!onError) {
+      plugins.push(await loadPlugin(config, baseDir));
+      continue;
+    }
+    try {
+      plugins.push(await loadPlugin(config, baseDir));
+    } catch (error) {
+      onError(config.use, error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  return plugins;
+}
+async function loadPluginsWithCss(configs, baseDir, onError) {
+  if (!configs || configs.length === 0) {
+    return { plugins: undefined, pluginStyles: [], pluginStylePaths: [] };
+  }
+  const plugins = await loadPlugins(configs, baseDir, onError);
+  return {
+    plugins,
+    pluginStyles: collectPluginStyleGroups(plugins),
+    pluginStylePaths: collectPluginStylePaths(plugins)
+  };
+}
+
+export { TWO_VERSIONS_OPEN, TWO_VERSIONS_CLOSE, MARKER_CSS, GUTTERPRESS_CSS, TWO_VERSIONS_CSS, TABLE_ALIGN_CSS, slugify, prettify, parseSrcsetUrlCandidates, collectHtmlImageRefs, createMarkdownRenderer, applyPlugins, collectPluginCss, collectPluginStylePaths, collectPluginStyleGroups, resolveDeclaredStyles, EXTENSION_MANIFEST_FILENAME, readExtensionMeta, extensionStyleList, extensionEntry, extensionCarries, assertExtensionContained, __resetPathPluginCacheForTests, loadPlugin, loadPublishFunction, loadPlugins, loadPluginsWithCss };