gutterpress 0.11.18-alpha.2 → 0.11.18-alpha.4

package/dist/lib/markdown/block-names.d.ts

@@ -0,0 +1,82 @@
+/**
+ * `data-name` — a stable hook for targeting ONE block from a stylesheet.
+ *
+ * A book's markdown holds content and semantic markers; its look lives in the
+ * plugin's and the book's CSS. What CSS needs, to restyle a single block
+ * without a markdown edit, is something on that block to select by. Class
+ * names are shared by every instance, an `id` is something the author must
+ * type, and position selectors break on any insertion. So every block this
+ * pipeline can name gets a `data-name`:
+ *
+ *   [data-name="sporos"] { break-inside: avoid; }
+ *   img[data-name="founder-house"] { float: right; width: 40%; }
+ *
+ * Plain HTML: a `data-*` attribute is standard, selected with the standard
+ * attribute selector, and nothing here is a behaviour a future browser
+ * feature would replace. The viewer never reads it; it exists for the
+ * author's CSS.
+ *
+ * WHAT GETS A NAME
+ *
+ *   Marker-opened blocks (`.chapter`, `.spread`, `.page`, `.section`, every
+ *   declared marker, `@columns` included, their variants too) take, in order:
+ *     1. the marker's explicit `name=` (core already emits it as `data-name`);
+ *     2. its `label=`, slugged;
+ *     3. the slug of the block's OWN first heading: the first heading whose
+ *        innermost marker block is this one, so a `@page` that holds a
+ *        `@section` does not borrow the section's title and the two never
+ *        share a name;
+ *     4. nothing. A block with no explicit name, label or own heading stays
+ *        unnamed rather than getting a position-based name that moves when
+ *        a block is inserted.
+ *   Headings take an explicit `{name=…}`, else the slug of their own text.
+ *   Images take an explicit `{name=…}`, else the slug of the file's basename
+ *   without its extension (see {@link nameFromSrc}, applied in images.ts).
+ *
+ * SLUGS: lower-case, accents folded to ASCII, apostrophes (' and ’) dropped,
+ * every run of other characters becomes one `-`, trimmed. `slug.ts`'s `slugify` plus a few letters NFKD
+ * does not decompose.
+ *
+ * COLLISIONS. Names are unique within one source file, because a file is
+ * rendered on its own (a book is the concatenation of its files):
+ *   - blocks share ONE namespace, so `[data-name="x"]` is exactly one block
+ *     in a file whatever its kind; headings have their own namespace, so a
+ *     section and its title can both be `sporos`. Pair the attribute with an
+ *     element (`h3[data-name="sporos"]`) or a class to say which;
+ *   - a later duplicate gets `-2`, `-3`, … in document order. Explicit names
+ *     are authored and never rewritten; they are reserved first, so a
+ *     derived name steps around them;
+ *   - images are NOT numbered: two images from the same file share a name,
+ *     which is usually what a book wants.
+ * A book that needs a name unique across files scopes the selector by chapter
+ * (`#ch-06 [data-name="x"]`) or types `name=`.
+ *
+ * CONTINUATIONS. A `gp-continued` section (made by `@continue`) is the SAME
+ * block, so it keeps its original's `data-name` and carries the
+ * `gp-continued` class; `:not(.gp-continued)` picks the first piece. It does
+ * NOT repeat the `id` (an id names one element; see markers.js).
+ *
+ * NO `id`s ARE ADDED. Ids feed `target-counter()` and links; inventing them
+ * would change what a document links to.
+ *
+ * Runs last among the built-in core rules and before any loaded plugin's own
+ * rules, so it sees `markdown-it-attrs`' result and a plugin sees the names.
+ */
+import type MarkdownIt from "markdown-it";
+import type Token from "markdown-it/lib/token.mjs";
+/** The `data-name` slug of `text`: `""` when nothing usable is left. */
+export declare function nameSlug(text: string): string;
+/**
+ * The image name for `src`: its file's basename without extension, slugged.
+ * `images/chapter-00/Founder%20House.png?v=2` is `founder-house`. A `data:`
+ * URI has no file name, so it has none.
+ */
+export declare function nameFromSrc(src: string): string;
+/**
+ * The author's explicit name on a token: `data-name`, or the `name` a
+ * `{name=…}` brace leaves behind (not a valid attribute on these elements, so
+ * it is moved to `data-name`). `""` when there is none.
+ */
+export declare function takeExplicitName(token: Token): string;
+/** Register the rule. Called by `createMarkdownRenderer` right after the marker plugin. */
+export declare function gpBlockNames(md: MarkdownIt): void;

package/dist/lib/markdown/renderer.d.ts

@@ -89,8 +89,9 @@ export interface GutterpressMarkerLabel {
  *
  * The close token has no meta. A `section: true` marker produces the core
  * `layout_section_open` / `layout_section_close` pair instead; its open token
- * carries `{ line, component, kind, variant, attrs }` (plus `continued: true`
- * on a `@continue` reopening) and a plain `@section`'s carries only `{ line }`.
+ * carries `{ line, component, kind, variant, attrs }` and a plain `@section`'s
+ * carries only `{ line }`; a `@continue` reopening of either adds
+ * `continued: true`.
  *
  * See `markers.js`'s header comment for a worked example and
  * `buildDeclaredMarkerRegistry` for the full validation/resolution contract

package/dist/lib/markdown/table-align.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Table column alignment as `data-align`, not an inline style.
+ *
+ * markdown-it writes `|:--|--:|` as `style="text-align:left"` on every cell.
+ * An inline style beats every stylesheet, so a book could never restyle a
+ * column without `!important`. The same fact as a plain attribute,
+ * `data-align="left|center|right"`, is applied by {@link TABLE_ALIGN_CSS} and
+ * loses to the book's own rules.
+ *
+ * Only markdown-it's own exact `text-align:` value is converted. An author's
+ * own `{style=…}` on a cell is left untouched.
+ */
+import type MarkdownIt from "markdown-it";
+export declare function gpTableAlign(md: MarkdownIt): void;
+/**
+ * The rules that apply `data-align`. `assemble.ts` injects them UNLAYERED,
+ * just before the book's own stylesheets, and with the natural specificity of
+ * an element plus an attribute (0,1,1). That puts them where the inline style
+ * they replace sat against the two things that used to lose to it:
+ *
+ *   - a plugin's default (`th { text-align: left }`, always in a cascade
+ *     layer): unlayered beats layered, so a markdown `:-:` still wins;
+ *   - a book's generic element rule (`th { text-align: left }`, specificity
+ *     0,0,1): the attribute selector outranks it, so the same book prints the
+ *     same. Measured on the user guide and the design guide, whose `th` rule
+ *     centred headers only until a layered version of these rules let it win.
+ *
+ * Unlike an inline style they can be overridden without `!important`: any
+ * book rule at least as specific that comes later wins, e.g.
+ * `td[data-align="right"] { text-align: center }` or `.stats td { … }`.
+ */
+export declare const TABLE_ALIGN_CSS = "\nth[data-align=\"left\"], td[data-align=\"left\"] { text-align: left; }\nth[data-align=\"center\"], td[data-align=\"center\"] { text-align: center; }\nth[data-align=\"right\"], td[data-align=\"right\"] { text-align: right; }\n";

package/dist/lib/printsafe.d.ts

@@ -2,6 +2,7 @@ export declare const ruleRemoteUrls = "printsafe/no-remote-urls";
 export declare const ruleRiskyProps = "printsafe/no-risky-print-effects";
 export declare const ruleSyntax = "printsafe/syntax-error";
 export declare const rulePageContainment = "printsafe/page-containment";
+export declare const rulePreviewCannotFollow = "printsafe/preview-cannot-follow";
 export interface PrintSafeWarning {
     rule: string;
     severity: "error" | "warning";

package/dist/lib/unknown-classes.d.ts

@@ -0,0 +1,12 @@
+import type Token from "markdown-it/lib/token.mjs";
+/** One class as the markdown uses it: where it first appears, and how often. */
+export interface ClassUse {
+    line: number;
+    count: number;
+}
+/** The author-written classes the tokens carry (`gp-*` and pipeline-emitted ones left out), keyed by class. */
+export declare function classesInTokens(tokens: readonly Token[]): Map<string, ClassUse>;
+/** Add every class a selector in `css` names to `into`. Unparseable CSS contributes what a text scan finds. */
+export declare function addCssClasses(css: string, into: Set<string>): void;
+/** The known class `cls` is most likely a typo of, or null: one edit for short names, two for longer ones. */
+export declare function nearestKnownClass(cls: string, known: ReadonlySet<string>): string | null;

package/dist/{manifest.schema-8m82f37q.json → manifest.schema-5pzhscqh.json}

@@ -243,7 +243,7 @@
         },
         "rules": {
           "type": "object",
-          "description": "Per-rule level overrides, keyed by rule id: a printsafe rule (printsafe/no-risky-print-effects, printsafe/page-containment, printsafe/no-remote-urls) or a check id such as source.accessibility.heading-order. \"off\" silences the rule; \"warn\" / \"error\" set its severity. An id that matches no rule is ignored. To silence one site instead, put a `gutterpress-disable-next-line <rule-id> -- reason` comment (CSS `/* */` or markdown `<!-- -->`) on the line above it.",
+          "description": "Per-rule level overrides, keyed by rule id: a printsafe rule (printsafe/no-risky-print-effects, printsafe/page-containment, printsafe/preview-cannot-follow, printsafe/no-remote-urls) or a check id such as source.accessibility.heading-order. \"off\" silences the rule; \"warn\" / \"error\" set its severity. An id that matches no rule is ignored. To silence one site instead, put a `gutterpress-disable-next-line <rule-id> -- reason` comment (CSS `/* */` or markdown `<!-- -->`) on the line above it.",
           "additionalProperties": { "enum": ["off", "warn", "error"] },
           "examples": [{ "printsafe/no-risky-print-effects": "off" }]
         }

package/dist/{new-w7q0n21v.js → new-ede0f1nm.js}

@@ -7,17 +7,17 @@ import {
   TARGET_IDS,
   scaffoldExtension,
   scaffoldProject
-} from "./cli-0w3961p5.js";
+} from "./cli-dmcy8kay.js";
 import {
   resolveGhostscript
-} from "./cli-qp6dtsh3.js";
+} from "./cli-36v78t6w.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-yqpnksaa.js";
+} from "./cli-88hddvbz.js";
 import"./cli-ht1bcqdd.js";
-import"./cli-161z4n0s.js";
+import"./cli-5x7s8bap.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";

package/dist/{preflight-m54qsjs7.js → preflight-b6c3k3qt.js}

@@ -2,17 +2,17 @@ import {
   executeValidation,
   publishTargetFor,
   reportMissingTools
-} from "./cli-0w3961p5.js";
+} from "./cli-dmcy8kay.js";
 import {
   log
-} from "./cli-qp6dtsh3.js";
+} from "./cli-36v78t6w.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-yqpnksaa.js";
+} from "./cli-88hddvbz.js";
 import"./cli-ht1bcqdd.js";
-import"./cli-161z4n0s.js";
+import"./cli-5x7s8bap.js";
 import {
   BuildError,
   EXIT_CODES

package/dist/{preview-bg3wxqxc.js → preview-y2dxxbrk.js}

@@ -7,10 +7,10 @@ import {
   runBuild,
   splitOutPath,
   startPreviewServer
-} from "./cli-0w3961p5.js";
+} from "./cli-dmcy8kay.js";
 import {
   log
-} from "./cli-qp6dtsh3.js";
+} from "./cli-36v78t6w.js";
 import {
   UsageError,
   parseFormat,
@@ -18,9 +18,9 @@ import {
   rejectExtraPositionals,
   rejectUnknownFlags,
   resolvePort
-} from "./cli-yqpnksaa.js";
+} from "./cli-88hddvbz.js";
 import"./cli-ht1bcqdd.js";
-import"./cli-161z4n0s.js";
+import"./cli-5x7s8bap.js";
 import {
   BuildError
 } from "./cli-46ycxe6r.js";

package/dist/{publish-waps63wf.js → publish-n60n0hm1.js}

@@ -11,18 +11,18 @@ import {
   publishProviderFor,
   resolvePublishFormat,
   runPublish
-} from "./cli-0w3961p5.js";
+} from "./cli-dmcy8kay.js";
 import {
   FileTokenStore,
   log
-} from "./cli-qp6dtsh3.js";
+} from "./cli-36v78t6w.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-yqpnksaa.js";
+} from "./cli-88hddvbz.js";
 import"./cli-ht1bcqdd.js";
-import"./cli-161z4n0s.js";
+import"./cli-5x7s8bap.js";
 import {
   EXIT_CODES
 } from "./cli-46ycxe6r.js";

package/dist/render.js

@@ -86,10 +86,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;
@@ -157,6 +158,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;
@@ -339,6 +342,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)) {
@@ -895,7 +903,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 || "",
@@ -993,12 +1005,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"))
@@ -1011,16 +1023,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;
       }
@@ -1084,24 +1094,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>
-`;
-  };
-  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>
+  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 = [
@@ -1453,6 +1449,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/chapter-id.ts
 function canonicalChapterId(p) {
   let s = String(p).replace(/\\/g, "/");
@@ -1598,6 +1615,152 @@ 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;
+}
+
+// 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";
@@ -1764,6 +1927,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");
@@ -2139,6 +2306,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);
@@ -2224,6 +2393,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(`

package/dist/{validate-c9d8d656.js → validate-2c7sfyxn.js}

@@ -1,16 +1,16 @@
 import {
   executeAndReport
-} from "./cli-0w3961p5.js";
+} from "./cli-dmcy8kay.js";
 import {
   log
-} from "./cli-qp6dtsh3.js";
+} from "./cli-36v78t6w.js";
 import {
   UsageError,
   rejectExtraPositionals,
   rejectUnknownFlags
-} from "./cli-yqpnksaa.js";
+} from "./cli-88hddvbz.js";
 import"./cli-ht1bcqdd.js";
-import"./cli-161z4n0s.js";
+import"./cli-5x7s8bap.js";
 import {
   BuildError,
   EXIT_CODES

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gutterpress",
-  "version": "0.11.18-alpha.2",
+  "version": "0.11.18-alpha.4",
   "description": "Markdown-to-PDF converter for professional print layout using a native Chromium print engine and Ghostscript.",
   "author": "itlackey",
   "license": "MPL-2.0",