gutterpress 0.11.18-alpha.3 → 0.11.18-alpha.5

package/dist/{index-rpc74pqb.js → index-r2ry6j3x.js}

@@ -9,7 +9,7 @@ import {
   getAssetsDir,
   lastPageMode,
   parseSize
-} from "./index-b81jc99n.js";
+} from "./index-pb4fj8m2.js";
 import {
   INSTALL_HINTS,
   execCapture,
@@ -786,10 +786,11 @@ function parseMarkerLine(line, declaredWords) {
   const kind = head.slice(1);
   if (!KNOWN_KINDS.includes(kind) && !(declaredWords && declaredWords.has(kind)))
     return null;
-  if (kind === "page-break" || kind === "column-break" || kind === "continue" || kind.startsWith("end-")) {
+  if (kind === "continue" || kind.startsWith("end-")) {
     return { kind, name: null, attrs: {} };
   }
-  const body = tokens.slice(1);
+  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;
@@ -857,6 +858,8 @@ function parseMarkerLine(line, declaredWords) {
   }
   if (classes.length)
     attrs.class = classes.join(" ");
+  if (isBreak)
+    return { kind, name: null, attrs };
   const marker = { kind, name, attrs };
   if (hasAmbiguousBareToken)
     marker.__ambiguousBareToken = true;
@@ -1039,6 +1042,11 @@ function attachDataAttrs(token, kind, name, attrs) {
     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)) {
@@ -1595,7 +1603,11 @@ function plugin(md, pluginOptions = {}) {
         attachDataAttrs(t, component.kind, component.variant, meta.attrs || {});
       else
         attachDataAttrs(t, "section", meta.name, meta.attrs || {});
-      t.meta = component ? { line: meta.__line, ...component, ...meta.__continued ? { continued: true } : {} } : { line: meta.__line };
+      t.meta = {
+        line: meta.__line,
+        ...component || {},
+        ...meta.__continued ? { continued: true } : {}
+      };
       stack.open({
         kind: "section",
         classes: meta.attrs && meta.attrs.class || "",
@@ -1693,12 +1705,12 @@ function plugin(md, pluginOptions = {}) {
         drainDeclaredFrames(keep);
         const contMeta = {
           name: section.meta.name,
-          attrs: { ...section.meta.attrs || {} }
+          attrs: { ...section.meta.attrs || {} },
+          __continued: true
         };
-        if (section.meta.component) {
+        delete contMeta.attrs.id;
+        if (section.meta.component)
           contMeta.__component = section.meta.component;
-          contMeta.__continued = true;
-        }
         contMeta.__line = line;
         const cls = (contMeta.attrs.class || "").split(/\s+/).filter(Boolean);
         if (!cls.includes("gp-continued"))
@@ -1711,16 +1723,14 @@ function plugin(md, pluginOptions = {}) {
       if (kind === "page-break") {
         const t = new state.Token("layout_page_break", "div", 0);
         t.meta = { line };
-        t.attrSet("class", "gp-page-break");
-        t.attrSet("aria-hidden", "true");
+        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 };
-        t.attrSet("class", "gp-column-break");
-        t.attrSet("aria-hidden", "true");
+        attachBreak(t, "gp-column-break", meta.attrs);
         out.push(t);
         continue;
       }
@@ -1784,24 +1794,10 @@ function plugin(md, pluginOptions = {}) {
       }
     });
   }
-  md.renderer.rules.layout_page_break = (tokens, idx) => {
-    const cls = tokens[idx].attrGet("class") || "gp-page-break";
-    const rangeAttr = tokens[idx].attrGet("data-source-range");
-    const rangeHtml = rangeAttr ? ` data-source-range="${escapeAttr(rangeAttr)}"` : "";
-    const chapterAttr = tokens[idx].attrGet("data-chapter-src");
-    const chapterHtml = chapterAttr ? ` data-chapter-src="${escapeAttr(chapterAttr)}"` : "";
-    return `<div class="${escapeAttr(cls)}" aria-hidden="true"${rangeHtml}${chapterHtml}></div>
+  const renderBreak = (tokens, idx, options2, env, self) => `<div${self.renderAttrs(tokens[idx])}></div>
 `;
-  };
-  md.renderer.rules.layout_column_break = (tokens, idx) => {
-    const cls = tokens[idx].attrGet("class") || "gp-column-break";
-    const rangeAttr = tokens[idx].attrGet("data-source-range");
-    const rangeHtml = rangeAttr ? ` data-source-range="${escapeAttr(rangeAttr)}"` : "";
-    const chapterAttr = tokens[idx].attrGet("data-chapter-src");
-    const chapterHtml = chapterAttr ? ` data-chapter-src="${escapeAttr(chapterAttr)}"` : "";
-    return `<div class="${escapeAttr(cls)}" aria-hidden="true"${rangeHtml}${chapterHtml}></div>
-`;
-  };
+  md.renderer.rules.layout_page_break = renderBreak;
+  md.renderer.rules.layout_column_break = renderBreak;
   md.renderer.rules.layout_marker = () => "";
 }
 var NO_MARGIN_BOXES = [
@@ -2153,6 +2149,27 @@ var GP_CLASSES = new Set([
   "gp-flush"
 ]);
 
+// 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/markdown/renderer.ts
 import MarkdownIt from "markdown-it";
 
@@ -2321,6 +2338,156 @@ function gpPinScope(md) {
   });
 }
 
+// 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 path = src.split(/[?#]/, 1)[0] ?? "";
+  const base = path.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/renderer.ts
 import markdownItSourceMap from "markdown-it-source-map";
 import markdownItDeflist from "markdown-it-deflist";
@@ -2487,6 +2654,10 @@ function registerImageRule(md) {
     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");
@@ -2862,6 +3033,8 @@ function createMarkdownRenderer(customPlugins) {
   const declaredMarkers = buildDeclaredMarkerRegistry(declaredMarkerSources);
   md.use(plugin, { declaredMarkers });
   md.use(gpPinScope);
+  md.use(gpBlockNames);
+  md.use(gpTableAlign);
   registerImageRule(md);
   if (customPlugins && customPlugins.length > 0) {
     applyPlugins(md, customPlugins);
@@ -2960,6 +3133,8 @@ ${GUTTERPRESS_CSS.trim()}
 }`,
     pluginCss ? `/* extension css */
 ${pluginCss.trim()}` : null,
+    `/* column alignment */
+${TABLE_ALIGN_CSS.trim()}`,
     projectCss ? `/* project css */
 ${projectCss.trim()}` : null
   ].filter(Boolean).join(`
@@ -4712,15 +4887,6 @@ async function rollbackNpmPluginInstall(installed) {
 // src/lib/extension-manager.ts
 import { gt as semverGt, rcompare as semverRcompare } from "semver";
 
-// 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/project-gitignore.ts
 import { readFile as readFile7, writeFile as writeFile2 } from "node:fs/promises";
 import path6 from "node:path";
@@ -5750,7 +5916,7 @@ import git from "isomorphic-git";
 // package.json
 var package_default = {
   name: "gutterpress",
-  version: "0.11.18-alpha.3",
+  version: "0.11.18-alpha.5",
   description: "Markdown-to-PDF converter for professional print layout using a native Chromium print engine and Ghostscript.",
   author: "itlackey",
   license: "MPL-2.0",
@@ -7620,6 +7786,8 @@ var ruleRemoteUrls = "printsafe/no-remote-urls";
 var ruleRiskyProps = "printsafe/no-risky-print-effects";
 var ruleSyntax = "printsafe/syntax-error";
 var rulePageContainment = "printsafe/page-containment";
+var rulePreviewCannotFollow = "printsafe/preview-cannot-follow";
+var ruleEngineHyphenation = "printsafe/engine-hyphenation";
 function extractUrls(value) {
   const urls = [];
   const re = /url\(\s*(['"]?)(.*?)\1\s*\)/gi;
@@ -7765,6 +7933,66 @@ function clipsDescendants(decl) {
   const v = decl.value.trim().toLowerCase();
   return v !== "" && !isInertValue(p, v);
 }
+var PREVIEW_AT_RULES = new Set(["media", "supports", "layer", "scope", "container", "document"]);
+var FORCED_BREAK_VALUE = /^(page|left|right|recto|verso)$/i;
+var LEGACY_FORCED_VALUE = /^(always|left|right)$/i;
+function previewBlindSpot(decl) {
+  const prop = decl.prop.toLowerCase();
+  const value = decl.value.trim();
+  const written = `${decl.prop}: ${decl.value}`;
+  const isBreak = prop === "break-before" || prop === "break-after";
+  const isLegacy = prop === "page-break-before" || prop === "page-break-after";
+  if (!isBreak && !isLegacy && prop !== "page")
+    return null;
+  const rules = [];
+  for (let p = decl.parent;p; p = p.parent) {
+    if (p.type === "rule")
+      rules.push(p);
+    else if (p.type === "atrule") {
+      const name = p.name.toLowerCase();
+      if (!PREVIEW_AT_RULES.has(name))
+        return null;
+    }
+  }
+  if (rules.length === 0)
+    return null;
+  const consequence = "the PDF honours it but the live preview does not show it, so the two page counts drift apart";
+  if (isLegacy) {
+    if (!LEGACY_FORCED_VALUE.test(value))
+      return null;
+    const modern = prop.replace("page-break-", "break-");
+    const siblings = decl.parent.nodes ?? [];
+    if (siblings.some((n) => n.type === "decl" && n.prop.toLowerCase() === modern))
+      return null;
+    const keyword = /^always$/i.test(value) ? "page" : value.toLowerCase();
+    return `"${written}" is the legacy spelling, and the live preview reads only ${modern}: ${consequence}. Write "${modern}: ${keyword}".`;
+  }
+  const viaVar = /\bvar\(/i.test(value);
+  if (isBreak && !viaVar && !FORCED_BREAK_VALUE.test(value))
+    return null;
+  if (prop === "page" && !viaVar && (value === "" || /^auto$/i.test(value)))
+    return null;
+  const what = prop === "page" ? "page assignment" : "forced break";
+  if (viaVar) {
+    return `The ${what} "${written}" uses var(): the live preview reads it only as a literal ${prop === "page" ? "page name" : "keyword (page, left, right, recto or verso)"}, so ${consequence}. Write the literal value.`;
+  }
+  const parent = decl.parent;
+  if (rules.length >= 2 || parent.type === "atrule") {
+    const outer = rules[rules.length - 1].selector;
+    return `The ${what} "${written}" is inside a nested rule in "${outer}": the live preview reads only top-level rules and rules inside @media, @supports, @layer, @scope, @container and @document, so ${consequence}. Move it to a flat rule of its own.`;
+  }
+  let prev = decl.prev();
+  while (prev && prev.type === "comment")
+    prev = prev.prev();
+  if (prev && (prev.type === "rule" || prev.type === "atrule" && prev.nodes)) {
+    return `The ${what} "${written}" comes right after a nested rule in "${rules[0].selector}": the live preview's CSS reader drops the first declaration after a nested block, so ${consequence}. Move the declaration above the nested rule.`;
+  }
+  return null;
+}
+function isAutoHyphenation(decl) {
+  const prop = decl.prop.toLowerCase();
+  return (prop === "hyphens" || prop === "-webkit-hyphens") && decl.value.trim().toLowerCase() === "auto";
+}
 function nodeLoc(node) {
   return {
     line: node.source?.start?.line ?? 1,
@@ -7877,6 +8105,22 @@ function checkCssRaw(css, from) {
       });
     }
   });
+  root.walkDecls((decl) => {
+    const message = previewBlindSpot(decl);
+    if (message) {
+      warnings.push({ rule: rulePreviewCannotFollow, severity: "warning", message, ...nodeLoc(decl) });
+    }
+  });
+  root.walkDecls((decl) => {
+    if (!isAutoHyphenation(decl))
+      return;
+    warnings.push({
+      rule: ruleEngineHyphenation,
+      severity: "warning",
+      message: `"${decl.prop}: auto" depends on the browser's hyphenation dictionaries, so the desktop app and the CLI (and different operating systems) can break lines and pages differently. Use "hyphens: manual" with soft hyphens (&shy;) for identical pages everywhere.`,
+      ...nodeLoc(decl)
+    });
+  });
   root.walkRules((rule) => {
     if (rule.parent?.type === "atrule") {
       const at = rule.parent.name.toLowerCase();
@@ -8688,10 +8932,117 @@ registerCheck(check25);
 
 // src/checks/source/layout-markers.ts
 import { readFile as readFile22 } from "node:fs/promises";
+
+// src/lib/unknown-classes.ts
+import postcss4 from "postcss";
+var EMITTED = new Set([
+  "chapter",
+  "spread",
+  "page",
+  "section",
+  "footnotes",
+  "footnotes-sep",
+  "footnote-ref",
+  "footnote-item",
+  "footnote-backref"
+]);
+function classesInTokens(tokens) {
+  const uses = new Map;
+  const note = (token, line) => {
+    const cls = token.attrs?.find(([key]) => key === "class")?.[1];
+    if (!cls)
+      return;
+    for (const c of cls.split(/\s+/)) {
+      if (!c || c.startsWith("gp-") || EMITTED.has(c) || /^chapter-\d+$/.test(c))
+        continue;
+      const seen = uses.get(c);
+      if (seen)
+        seen.count++;
+      else
+        uses.set(c, { line, count: 1 });
+    }
+  };
+  for (const token of tokens) {
+    const meta = token.meta;
+    const line = token.map ? token.map[0] + 1 : typeof meta?.line === "number" ? meta.line : 0;
+    note(token, line);
+    for (const child of token.children ?? [])
+      note(child, line);
+  }
+  return uses;
+}
+var CLASS_RE = /\.((?:[\w -￿-]|\\.)+)/g;
+function addSelectorClasses(selector, into) {
+  const bare = selector.replace(/\[(?:[^\]"']|"[^"]*"|'[^']*')*\]/g, "").replace(/"[^"]*"|'[^']*'/g, "");
+  for (const m of bare.matchAll(CLASS_RE)) {
+    const name = m[1].replace(/\\(.)/g, "$1");
+    if (!/^\d/.test(name))
+      into.add(name);
+  }
+}
+function addCssClasses(css, into) {
+  try {
+    postcss4.parse(css).walk((node) => {
+      if (node.type === "rule")
+        addSelectorClasses(node.selector, into);
+      else if (node.type === "atrule") {
+        const at = node;
+        if (/^(scope|container)$/i.test(at.name))
+          addSelectorClasses(at.params, into);
+      }
+    });
+  } catch {
+    addSelectorClasses(css.replace(/\/\*[\s\S]*?\*\//g, ""), into);
+  }
+}
+function editDistance3(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 nearestKnownClass(cls, known) {
+  const limit = cls.length >= 6 ? 2 : 1;
+  let best = null;
+  let bestDistance = limit + 1;
+  for (const candidate of known) {
+    if (Math.abs(candidate.length - cls.length) > limit)
+      continue;
+    const d = editDistance3(cls, candidate);
+    if (d > 0 && d < bestDistance) {
+      best = candidate;
+      bestDistance = d;
+    }
+  }
+  return best;
+}
+
+// src/checks/source/layout-markers.ts
+async function collectKnownClasses(ctx, plugins) {
+  const names = new Set;
+  addCssClasses(MARKER_CSS, names);
+  addCssClasses(GUTTERPRESS_CSS, names);
+  for (const p of plugins)
+    if (p.css)
+      addCssClasses(p.css, names);
+  const roots = [...ctx.cssFiles ?? [], ...plugins.flatMap((p) => p.styles ?? [])];
+  const sheets = (await collectStyleDependencies(ctx.inputDir, roots)).filter((f) => /\.css$/i.test(f));
+  for (const sheet of sheets) {
+    try {
+      addCssClasses(await readFile22(sheet, "utf8"), names);
+    } catch {}
+  }
+  return names;
+}
 var check26 = {
   id: "source.markdown.layout-markers",
   name: "Layout Markers",
-  description: "Reports @page/@section/@chapter marker arguments Gutterpress could not understand, plus any unknown gp-* class",
+  description: "Reports @page/@section/@chapter marker arguments Gutterpress could not understand, plus any unknown gp-* class and any other class no stylesheet mentions",
   category: "source",
   phase: "pre-build",
   async run(ctx) {
@@ -8703,11 +9054,31 @@ var check26 = {
       results.push(inspectionFailed(check26.id, `Plugin "${ref}" could not be loaded, so markers it defines were not checked: ${error2.message}`));
     });
     const md = createMarkdownRenderer(plugins);
+    let known;
+    const knownClasses = () => known ??= collectKnownClasses(ctx, plugins);
     for (const file of files) {
       try {
         const content = await readFile22(file, "utf8");
         const env = {};
-        md.render(content, env);
+        const tokens = md.parse(content, env);
+        md.renderer.render(tokens, md.options, env);
+        const uses = classesInTokens(tokens);
+        if (uses.size > 0) {
+          const names = await knownClasses();
+          const warnedLines = new Set((env.layoutWarnings ?? []).map((w) => w.line));
+          for (const [cls, use] of uses) {
+            if (names.has(cls) || warnedLines.has(use.line))
+              continue;
+            const guess = nearestKnownClass(cls, names);
+            results.push(finding(check26.id, {
+              severity: "warning",
+              message: `Class ".${cls}" is not in any stylesheet (Gutterpress's own, the plugins', or this book's), so it styles nothing.` + (guess ? ` Did you mean ".${guess}"?` : "") + (use.count > 1 ? ` Used ${use.count} times in this file; the first is reported.` : ""),
+              file,
+              ...use.line > 0 ? { line: use.line } : {},
+              code: "unknown_class"
+            }));
+          }
+        }
         for (const w of env.layoutWarnings ?? []) {
           results.push(finding(check26.id, {
             severity: w.severity ?? "warning",
@@ -10306,7 +10677,7 @@ class PdfOutput {
       const rawPdf = pdfxMode ? path13.join(stage, "raw.pdf") : path13.resolve(pdfFile);
       await fsp2.mkdir(path13.dirname(path13.resolve(pdfFile)), { recursive: true });
       log.info("Rendering HTML to PDF via the Gutterpress engine (native Chromium pagination)");
-      const { buildNativePdf } = await import("./engine-68avsbe2.js");
+      const { buildNativePdf } = await import("./engine-wjz5yhmp.js");
       const engineDiagnostics = await buildNativePdf(htmlFile, rawPdf, {
         title: config.title,
         author: config.authors.length > 0 ? config.authors.join(", ") : undefined,
@@ -11782,7 +12153,7 @@ import path20 from "node:path";
 import { existsSync as existsSync13 } from "node:fs";
 import { mkdir as mkdir8, readFile as readFile29, writeFile as writeFile8 } from "node:fs/promises";
 import path19 from "node:path";
-import postcss4 from "postcss";
+import postcss5 from "postcss";
 import { Scalar as Scalar2 } from "yaml";
 function isPositivePoints(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0;
@@ -11843,7 +12214,7 @@ function sizeDeclsOf(rule) {
 function readPageSizeFromCss(css) {
   let root;
   try {
-    root = postcss4.parse(css);
+    root = postcss5.parse(css);
   } catch {
     return null;
   }
@@ -11852,7 +12223,7 @@ function readPageSizeFromCss(css) {
   return last ? parseSize(last.value) ?? null : null;
 }
 function setPageSizeInCss(css, page) {
-  const root = postcss4.parse(css);
+  const root = postcss5.parse(css);
   const decls = plainPageRules(root).flatMap(sizeDeclsOf);
   const last = decls[decls.length - 1];
   const value = formatPageSize(page);

package/dist/index.js

@@ -153,14 +153,14 @@ import {
   testRemoteAccess,
   updateExtensions,
   validateProjectExtensions
-} from "./index-rpc74pqb.js";
+} from "./index-r2ry6j3x.js";
 import"./index-ht1bcqdd.js";
 import {
   BUILD_DIAGNOSTIC_CODES
-} from "./index-q88g67zg.js";
+} from "./index-89zg3jtk.js";
 import {
   BuildError
-} from "./index-b81jc99n.js";
+} from "./index-pb4fj8m2.js";
 import {
   DEFAULT_PRINT_OPTS,
   assertMilestone,