@geml/geml 1.7.8 → 1.8.2

package/dist/geml.js

@@ -18,7 +18,7 @@ import { readFileSync, realpathSync } from "node:fs";
 import { dirname, join, resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
 import { normalizeSource } from "./diagnostics.js";
-import { coerce, parseAttrs } from "./attrs.js";
+import { coerce, oddNames, parseAttrs } from "./attrs.js";
 import { META_REF_SRC, parseInline, isSafeUrl, schemeOf } from "./inline.js";
 import { parseTable } from "./table.js";
 import { USES, buildChart } from "./chart.js";
@@ -91,17 +91,26 @@ function jsonErrorLine(e, text, openLineNo) {
 export { SEVERITY } from "./diagnostics.js";
 // Type registry: which body mode each typed block uses. Unknown types are a
 // warning and fall back to `raw` (forward compatibility, §3/§8).
-const REGISTRY = {
-    code: "raw",
-    diagram: "raw",
-    math: "raw",
-    table: "raw", // structured table parsing lands in M3
-    data: "raw", // GEP-0005: value tree — a format engine parses the raw body in a second stage
-    embed: "raw", // block transclusion: `src=` points at the content, body unused
-    note: "flow",
-    text: "flow", // addressable prose container: an id/attrs for a run of flow, no callout chrome
-    meta: "data",
-};
+//
+// A Map, not an object, because the key is the type name off a fence head — i.e.
+// document-controlled. Indexing a plain object with it answered for the whole
+// prototype chain: `=== constructor` (also toString, valueOf, hasOwnProperty,
+// isPrototypeOf, propertyIsEnumerable, toLocaleString) returned an inherited
+// FUNCTION, which is not undefined, so the unknown-block-type warning never
+// fired and a function reached the model's `mode` field — a value the published
+// `BodyMode` type says cannot occur, and one JSON.stringify silently drops.
+// Every other document-keyed registry here is already a Set or a Map.
+const REGISTRY = new Map([
+    ["code", "raw"],
+    ["diagram", "raw"],
+    ["math", "raw"],
+    ["table", "raw"], // structured table parsing lands in M3
+    ["data", "raw"], // GEP-0005: value tree — a format engine parses the raw body in a second stage
+    ["embed", "raw"], // block transclusion: `src=` points at the content, body unused
+    ["note", "flow"],
+    ["text", "flow"], // addressable prose container: an id/attrs for a run of flow, no callout chrome
+    ["meta", "data"],
+]);
 // §7: built-in diagram renderer registry. Unknown formats are a warning (the
 // processor keeps the body raw rather than interpreting it).
 const DIAGRAM_RENDERERS = new Set(["mermaid", "graphviz", "dot", "d2", "plantuml", "geml-chart", "geml-code-graph"]);
@@ -133,6 +142,21 @@ export const FENCE_OPEN = /^(={3,})[ \t]+([A-Za-z][A-Za-z0-9_-]*)[ \t]*(?:(\{.*\
 // Together: the group runs to the end of the line and starts at the first `{`
 // after the last OTHER `}`. Returns the RegExpExecArray shape the call sites
 // already destructure.
+// A name in the attribute object that is not a NAME (§4). A WARNING, not an
+// error: it has always parsed, documents in the wild rely on the leniency, and
+// what the author needs is to be told — `{#a & b}` gives the id `a` and two
+// flags called `&` and `b`, which is a legal parse of something nobody wrote.
+function reportOddNames(a, line, diags) {
+    for (const { kind, name } of oddNames(a)) {
+        diags.push({
+            severity: "warning",
+            code: "name-not-a-name",
+            message: `${kind} \`${name}\` is not a NAME (§4: letters, digits, \`-\`, \`_\`)`
+                + (kind === "flag" ? " — an attribute object is whitespace-separated, so a space in an id or class splits it into flags like this one" : ""),
+            line,
+        });
+    }
+}
 const HEADING_HEAD = /^(#{1,6})[ \t]+/;
 function matchHeading(line) {
     const m = HEADING_HEAD.exec(line);
@@ -184,7 +208,7 @@ function slug(text) {
     return text
         .toLowerCase()
         .replace(/`[^`]*`/g, "")
-        .replace(/[^\p{L}\p{N}\s-]/gu, "")
+        .replace(/[^\p{L}\p{N}\s\-_]/gu, "")
         .trim()
         .replace(/\s+/g, "-");
 }
@@ -405,6 +429,7 @@ function scanBlocks(lines, base, ctx, depth = 0) {
             const type = open[2];
             const attrs = open[3] ? parseAttrs(open[3]) : { classes: [], attrs: {} };
             const openLineNo = base + i + 1;
+            reportOddNames(attrs, openLineNo, diags);
             // Collect the body. A block closes on the FIRST line that is a bare fence
             // of exactly the opening length, OR — when it has an id — a labeled fence
             // `=== #id` (a `=` run of any length ≥ 3 followed by the block's id). The
@@ -439,7 +464,7 @@ function scanBlocks(lines, base, ctx, depth = 0) {
                 const how = attrs.id !== undefined ? `${"=".repeat(openLen)} or \`=== #${attrs.id}\`` : "=".repeat(openLen);
                 diags.push({ severity: "error", code: "unterminated-block", message: `unterminated \`${type}\` block (no matching ${how})`, line: openLineNo });
             }
-            let mode = REGISTRY[type];
+            let mode = REGISTRY.get(type);
             if (mode === undefined) {
                 diags.push({ severity: "warning", code: "unknown-block-type", message: `unknown block type \`${type}\`; body kept as raw`, line: openLineNo });
                 mode = "raw";
@@ -663,6 +688,7 @@ function scanBlocks(lines, base, ctx, depth = 0) {
             const level = h[1].length;
             const rawText = h[2];
             const a = parseAttrs(h[3] ?? "");
+            reportOddNames(a, lineNo, diags);
             const text = interpolate(rawText, lineNo, ctx);
             const id = a.id ?? slug(rawText);
             registerId(ctx, id, lineNo);
@@ -1111,8 +1137,9 @@ function gatherIds(source) {
 }
 // Pre-scan for `=== meta` blocks (at any fence depth) and merge their
 // `key=val` lines, so `{{key}}` interpolation can resolve forward references.
-function collectMeta(lines) {
+function collectMeta(lines, diags) {
     const meta = new Map();
+    const firstLine = new Map(); // key → 1-based line of the defining fence
     for (let i = 0; i < lines.length; i++) {
         const open = FENCE_OPEN.exec(lines[i]);
         if (!open || open[2] !== "meta")
@@ -1122,8 +1149,17 @@ function collectMeta(lines) {
         let j = i + 1;
         for (; j < lines.length && !isCloseFence(lines[j], len); j++)
             body.push(lines[j]);
-        for (const [k, v] of Object.entries(parseData(body)))
-            meta.set(k, String(v));
+        for (const [k, v] of Object.entries(parseData(body))) {
+            if (meta.has(k)) {
+                diags?.push({ severity: "warning", code: "duplicate-meta-key",
+                    message: `meta key \`${k}\` already defined at line ${firstLine.get(k)}; later definition at line ${i + 1} is ignored`,
+                    line: i + 1 });
+            }
+            else {
+                meta.set(k, String(v));
+                firstLine.set(k, i + 1);
+            }
+        }
         i = j;
     }
     return meta;
@@ -1283,13 +1319,14 @@ function resolveCodeSources(ctx, opts) {
         if (slice === null)
             continue;
         const hasBody = (block.raw ?? []).some((l) => l.trim() !== "");
-        if (!hasBody) {
-            block.raw = slice;
+        if (hasBody) {
+            // A code block must not carry both src= and an inline body (§3.3).
+            ctx.diags.push({ severity: "error", code: "code-src-and-body",
+                message: `code: carries both \`src=\` and an inline body; exactly one is permitted`,
+                line });
         }
-        else if ((block.raw ?? []).join("\n") !== slice.join("\n")) {
-            // A body alongside `src=` is a cached snapshot, kept for offline reading.
-            // Silence would let the two drift — the very thing the route prevents.
-            ctx.diags.push({ severity: "warning", code: "stale-code-snapshot", message: `code block body differs from its source \`${target}\` — the body is a snapshot and is now out of date`, line });
+        else {
+            block.raw = slice;
         }
     }
 }
@@ -1547,7 +1584,8 @@ function resolveCharts(ctx, opts) {
 }
 export function parse(source, opts = {}) {
     const lines = normalizeSource(source).split("\n");
-    const ctx = { diags: [], ids: new Map(), refs: [], meta: collectMeta(lines), resolveDoc: opts.resolveDoc };
+    const diags = [];
+    const ctx = { diags, ids: new Map(), refs: [], meta: collectMeta(lines, diags), resolveDoc: opts.resolveDoc };
     const children = scanBlocks(lines, 0, ctx);
     // Table sources first: a chart reads the build-time model of the table it
     // charts, so that model has to be filled before charts are resolved.
@@ -1659,7 +1697,7 @@ units) {
             // Only a flow body is scanned for nested blocks (raw/data bodies are
             // opaque), so an id inside a `code` body is *not* addressable — exactly
             // the parser's contract.
-            if ((REGISTRY[type] ?? "raw") === "flow" && depth < MAX_NESTING) {
+            if ((REGISTRY.get(type) ?? "raw") === "flow" && depth < MAX_NESTING) {
                 collectSpans(lines.slice(i + 1, closed ? end - 1 : end), base + i + 1, out, ctx, depth + 1, units);
             }
             i = end;

package/dist/inline.d.ts

@@ -70,4 +70,10 @@ export interface RefSink {
 export declare const META_REF_SRC = "\\{\\{\\s*([A-Za-z_][A-Za-z0-9_-]*)\\s*\\}\\}";
 export declare function schemeOf(url: string): string | null;
 export declare function isSafeUrl(url: string, allowDataImage?: boolean): boolean;
-export declare function parseInline(s: string, line: number, sink: RefSink, depth?: number): Inline[];
+interface Pairs {
+    br: Int32Array;
+    pa: Int32Array;
+    off: number;
+}
+export declare function parseInline(s: string, line: number, sink: RefSink, depth?: number, pairs?: Pairs): Inline[];
+export {};