@geml/geml 1.1.1 → 1.4.2

package/dist/block-edit.js

@@ -0,0 +1,112 @@
+// Structural id-rewriting for `geml set`. `set #id` names the block to edit,
+// so the content spliced in must ADOPT that id — whatever id it declared (or
+// none). This module performs that rewrite parse-aware (per head form) rather
+// than by blind byte replacement, touching ONLY the id: type, classes,
+// attributes, body and the fence pairing all ride along unchanged.
+//
+// Deliberately self-contained — it imports only the shared attribute parser,
+// never geml.ts: geml.ts's module body runs the CLI on import, so a back-import
+// would fire the whole command line just by loading this helper.
+import { parseAttrs } from "./attrs.js";
+// The two head forms, spelled to MIRROR geml.ts's FENCE_OPEN / HEADING (same
+// language) but with the id-bearing brace tail split out so the id can be
+// rewritten while every other byte is copied verbatim:
+//   FENCE_HEAD  g1 = `=== type`   g2 = ws   g3 = `{…}`?   g4 = trailing ws
+//   HEAD_HEAD   g1 = `## text`    g2 = ws   g3 = `{…}`?   g4 = trailing ws
+const FENCE_HEAD = /^(={3,}[ \t]+[A-Za-z][A-Za-z0-9_-]*)([ \t]*)(\{.*\})?([ \t]*)$/;
+const HEAD_HEAD = /^(#{1,6}[ \t]+.*?)([ \t]*)(\{[^}]*\})?([ \t]*)$/;
+// Split into physical lines while keeping each line's terminator, so join("")
+// is byte-exact — the same boundaries geml.ts's splitLines() uses. A line ends
+// at `\n`, `\r\n`, or a lone `\r`.
+function splitLines(source) {
+    return source.split(/(?<=\n|\r(?!\n))/);
+}
+// Strip a single trailing terminator from one physical line.
+function stripEnding(line) {
+    return line.replace(/(\r\n|\r|\n)$/, "");
+}
+// Rewrite the id inside a `{…}` attribute block to `#newId`, keeping the braces
+// and every other class/attr byte. If no id is present, insert `#newId` as the
+// first token. The id token sits at a token boundary (`{` or whitespace) and
+// never inside a quoted value, so the anchored match can't disturb a value like
+// `caption="#x"`.
+function rewriteBraces(braces, newId) {
+    if (parseAttrs(braces).id !== undefined) {
+        return braces.replace(/([{\s])#[^\s}]+/, `$1#${newId}`);
+    }
+    const inner = braces.slice(1, -1).replace(/^[ \t]*/, "");
+    return `{#${newId}${inner.length ? " " + inner : ""}}`;
+}
+// Rewrite a HEAD line's id declaration to `#newId`. Handles both head forms and
+// all id states: existing brace id, brace attrs without an id, and no braces at
+// all (append `{#newId}`). A line that is neither form is returned unchanged.
+function rewriteHead(head, newId) {
+    const rebuild = (m) => {
+        const lead = m[1], ws = m[2] ?? "", braces = m[3], trail = m[4] ?? "";
+        if (braces)
+            return lead + ws + rewriteBraces(braces, newId) + trail;
+        return `${lead} {#${newId}}${ws}${trail}`;
+    };
+    const f = FENCE_HEAD.exec(head);
+    if (f)
+        return rebuild(f);
+    const h = HEAD_HEAD.exec(head);
+    if (h)
+        return rebuild(h);
+    return head;
+}
+// Locate the block's HEAD: the first non-blank, non-`%%` line that opens a fence
+// or a heading. Returns its line index, or -1 when the content has no head
+// (pure prose, or a structural line that is not a head) — the caller decides
+// what that means.
+function findHead(lines) {
+    for (let i = 0; i < lines.length; i++) {
+        const t = stripEnding(lines[i]);
+        if (t.trim() === "" || /^[ \t]*%%/.test(t))
+            continue;
+        if (FENCE_HEAD.test(t) || HEAD_HEAD.test(t))
+            return i;
+        return -1; // the first structural line isn't a head: no addressable block
+    }
+    return -1;
+}
+// Rewrite the HEAD id of the first block in `blockSrc` to `newId`, across every
+// head form:
+//   • fence attrs `{#x …}`  -> `{#newId …}` (other classes/attrs kept)
+//   • fence with attrs but no id, or no braces -> gains `{#newId}`
+//   • labeled close `=== #x` -> `=== #newId` (renamed to match the open)
+//   • heading `## T {#x}`    -> `## T {#newId}`
+//   • heading auto-slug (no braces) -> `## T {#newId}` appended
+// Only the id changes; type / classes / attrs / body / fence length are byte-
+// preserved, as are line terminators. Content with no head is returned as-is.
+export function normalizeBlockId(blockSrc, newId) {
+    const lines = splitLines(blockSrc);
+    const hi = findHead(lines);
+    if (hi < 0)
+        return blockSrc;
+    const headText = stripEnding(lines[hi]);
+    const headTerm = lines[hi].slice(headText.length);
+    lines[hi] = rewriteHead(headText, newId) + headTerm;
+    // For a fence carrying an id, a labeled close `=== #oldId` names that id and
+    // must be renamed too — otherwise the open declares #newId while the close
+    // still labels #oldId and the block no longer parses. The FIRST close wins
+    // (plain equal-length OR labeled), matching geml.ts's fenceClose scan; a
+    // plain close needs no rewrite.
+    const f = FENCE_HEAD.exec(headText);
+    const oldId = f && f[3] ? parseAttrs(f[3]).id : undefined;
+    if (f && oldId !== undefined) {
+        const openLen = /^=+/.exec(f[1])[0].length;
+        for (let j = hi + 1; j < lines.length; j++) {
+            const ct = stripEnding(lines[j]);
+            const trimmed = ct.replace(/[ \t]+$/, "");
+            if (/^=+$/.test(trimmed) && trimmed.length === openLen)
+                break; // plain close: done
+            const cm = /^(={3,}[ \t]+#)([^\s}]+)([ \t]*)$/.exec(ct);
+            if (cm && cm[2] === oldId) {
+                lines[j] = cm[1] + newId + cm[3] + lines[j].slice(ct.length);
+                break;
+            }
+        }
+    }
+    return lines.join("");
+}

package/dist/from-md.js

@@ -14,6 +14,7 @@
 //   thematic break (---/***) -> dropped           (§1: not part of GEML)
 //
 // Anything else (ATX headings, lists, paragraphs) is already valid GEML.
+import { META_REF_SRC } from "./inline.js";
 // Pick a fence length longer than any run of `=` that appears alone on a body
 // line (leading indentation included), so the close fence stays unambiguous
 // (§3 equal-length close rule) and the body's own `=` fences nest safely.
@@ -68,6 +69,63 @@ function autolinks(s) {
             .replace(/<mailto:([^>\s]+)>/g, "[$1](mailto:$1)"))
         .join("");
 }
+// A literal `{{name}}` in Markdown prose is plain text (Markdown has no
+// metadata interpolation), but converted GEML flow text would read it as a §4
+// reference — an unknown key fails `geml check`, and a key that happens to
+// exist in the generated `=== meta` block substitutes silently. Escape it to
+// `\{{name}}`, skipping the spans GEML interpolation itself leaves verbatim
+// (inline code, inline math) and already-escaped characters.
+const META_REF_Y = new RegExp(META_REF_SRC, "y");
+function escMetaRefs(s) {
+    if (!s.includes("{{"))
+        return s;
+    let out = "";
+    let i = 0;
+    while (i < s.length) {
+        const c = s[i];
+        if (c === "\\" && i + 1 < s.length) {
+            out += s.slice(i, i + 2);
+            i += 2;
+            continue;
+        }
+        if (c === "`") {
+            let n = 0;
+            while (s[i + n] === "`")
+                n++;
+            const close = s.indexOf("`".repeat(n), i + n);
+            if (close >= 0) {
+                out += s.slice(i, close + n);
+                i = close + n;
+                continue;
+            }
+            out += s.slice(i, i + n);
+            i += n;
+            continue;
+        }
+        if (c === "$") {
+            const close = s.indexOf("$", i + 1);
+            if (close > i + 1) {
+                out += s.slice(i, close + 1);
+                i = close + 1;
+                continue;
+            }
+            out += c;
+            i++;
+            continue;
+        }
+        if (c === "{" && s[i + 1] === "{") {
+            META_REF_Y.lastIndex = i;
+            if (META_REF_Y.test(s)) {
+                out += "\\{";
+                i++;
+                continue;
+            }
+        }
+        out += c;
+        i++;
+    }
+    return out;
+}
 // GitHub-style heading anchor: drop code backticks (keep content), lowercase,
 // strip punctuation except `-`/`_`, collapse whitespace to hyphens. Used to keep
 // converted headings' ids in sync with Markdown TOC links.
@@ -151,12 +209,12 @@ export function mdToGeml(source) {
         if (line.trim() !== "" && !THEMATIC.test(line) && i + 1 < lines.length) {
             const nxt = lines[i + 1];
             if (SETEXT_UL.test(nxt)) {
-                out.push(`# ${line.trim()}`);
+                out.push(`# ${escMetaRefs(line.trim())}`);
                 i += 2;
                 continue;
             }
             if (SETEXT_DASH.test(nxt)) {
-                out.push(`## ${line.trim()}`);
+                out.push(`## ${escMetaRefs(line.trim())}`);
                 i += 2;
                 continue;
             }
@@ -183,7 +241,7 @@ export function mdToGeml(source) {
                 else
                     break;
             }
-            emitBlock(out, "note", `{#${fn[1].trim()}}`, body.map(autolinks), ids);
+            emitBlock(out, "note", `{#${fn[1].trim()}}`, body.map((l) => escMetaRefs(autolinks(l))), ids);
             i = j;
             continue;
         }
@@ -191,7 +249,7 @@ export function mdToGeml(source) {
         if (/^\s*>/.test(line)) {
             const body = [];
             while (i < lines.length && /^\s*>/.test(lines[i])) {
-                body.push(lines[i].replace(/^\s*>\s?/, ""));
+                body.push(escMetaRefs(lines[i].replace(/^\s*>\s?/, "")));
                 i++;
             }
             emitBlock(out, "note", "", body, ids);
@@ -220,13 +278,14 @@ export function mdToGeml(source) {
         if (atx && atx[2].includes("`") && !/\{[^}]*\}\s*$/.test(atx[2])) {
             const id = githubSlug(atx[2]);
             if (id) {
-                out.push(`${atx[1]} ${atx[2]} {#${id}}`);
+                out.push(`${atx[1]} ${escMetaRefs(atx[2])} {#${id}}`);
                 i++;
                 continue;
             }
         }
-        // Inline pass: rewrite autolinks to GEML links (outside code spans).
-        const text = autolinks(line);
+        // Inline pass: rewrite autolinks to GEML links, escape literal `{{name}}`
+        // (both outside code spans).
+        const text = escMetaRefs(autolinks(line));
         // Raw HTML note — ignore `<…>` that sits inside an inline code span.
         if (/<[a-zA-Z/]/.test(text.replace(/`[^`]*`/g, ""))) {
             notes.push(`raw HTML kept as text at line ${i + 1}: ${line.trim().slice(0, 40)}`);

package/dist/geml.d.ts

@@ -7,7 +7,8 @@ export { type Value } from "./attrs.js";
 export { type Inline } from "./inline.js";
 export { type TableModel } from "./table.js";
 export { mdToGeml, type ConvertResult } from "./from-md.js";
-export { renderHtml, type RenderOptions } from "./render.js";
+export { renderHtml } from "./render-html.js";
+export { type RenderOptions } from "./render.js";
 export { serialize } from "./serialize.js";
 export { gemlToMd } from "./to-md.js";
 export type BodyMode = "raw" | "flow" | "data";