@diagrammo/dgmo 0.89.0 → 0.90.0

package/dist/chunk-IHK3Y2HG.js

@@ -0,0 +1,781 @@
+import {
+  parseFirstLine,
+  recognizeGlobalBoolean
+} from "./chunk-MPJQMMBZ.js";
+import {
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-BYU54C3S.js";
+
+// src/whiteboard/diagnostics.ts
+var WHITEBOARD_DIAGNOSTIC_CODES = {
+  UNKNOWN_ELEMENT: "W_WHITEBOARD_UNKNOWN_ELEMENT",
+  BAD_GEOMETRY: "W_WHITEBOARD_BAD_GEOMETRY",
+  OUT_OF_RANGE: "W_WHITEBOARD_OUT_OF_RANGE",
+  UNKNOWN_COLOR: "W_WHITEBOARD_UNKNOWN_COLOR",
+  UNKNOWN_KEY: "W_WHITEBOARD_UNKNOWN_KEY",
+  UNKNOWN_STYLE: "W_WHITEBOARD_UNKNOWN_STYLE",
+  BAD_VALUE: "W_WHITEBOARD_BAD_VALUE",
+  BAD_INK: "W_WHITEBOARD_BAD_INK",
+  BAD_IMAGE_REF: "W_WHITEBOARD_BAD_IMAGE_REF",
+  EMPTY_TEXT: "W_WHITEBOARD_EMPTY_TEXT",
+  UNEXPECTED_BODY: "W_WHITEBOARD_UNEXPECTED_BODY"
+};
+var s = (v) => typeof v === "string" || typeof v === "number" ? String(v) : "?";
+var WHITEBOARD_DIAGNOSTICS = [
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.UNKNOWN_ELEMENT,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Unknown whiteboard element",
+    message: (p) => `Unknown element "${s(p.word)}" \u2014 a whiteboard line starts with rectangle, ellipse, database, queue, note, arrow, line, text, image or ink; line skipped${p.hint ? `. ${s(p.hint)}` : ""}`,
+    hint: "Start the line with one of the ten element keywords.",
+    example: "whiteboard\nsquare Start at: 0 0, size: 120 60"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.BAD_GEOMETRY,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Missing or malformed position",
+    message: (p) => `${s(p.element)} needs ${s(p.need)} \u2014 got ${s(p.got)}; line skipped`,
+    hint: "Positions and sizes are two whole numbers separated by a space: at: 40 -20, size: 160 80.",
+    example: "whiteboard\nellipse Idea at: 40, size: 160 80"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.OUT_OF_RANGE,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Coordinate out of range",
+    message: (p) => `${s(p.key)}: "${s(p.raw)}" is out of range \u2014 coordinates stay within \xB1${s(p.max)} px and sizes are at least 1; line skipped`,
+    hint: "Keep the board near the origin; a runaway drag value is the usual cause.",
+    example: "whiteboard\nrectangle at: 0 0, size: 0 50"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.UNKNOWN_COLOR,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Unknown colour",
+    message: (p) => `Unknown colour "${s(p.color)}" \u2014 drawn in ${p.fallback ? s(p.fallback) : "ink"} (valid: ink, red, green, blue, teal, purple, orange, yellow, cyan, gray)${p.hint ? `. ${s(p.hint)}` : ""}`,
+    hint: "Colours are palette names, never hex values.",
+    example: "whiteboard\ntext Ship it at: 0 0, color: crimson"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.UNKNOWN_KEY,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Unknown metadata key",
+    message: (p) => `Unknown key "${s(p.key)}" on ${s(p.element)} \u2014 ignored (valid here: ${s(p.valid)})${p.hint ? `. ${s(p.hint)}` : ""}`,
+    hint: 'Quote a label that itself contains "word:" so it is not read as a key.',
+    example: "whiteboard\ntext Ship at: 0 0, colour: red"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.UNKNOWN_STYLE,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Unknown line style",
+    message: (p) => `Unknown style "${s(p.style)}" \u2014 drawn solid (valid: dashed; solid is the default and never written)${p.hint ? `. ${s(p.hint)}` : ""}`,
+    hint: "Arrows and lines take `style: dashed`; leave style off for a solid stroke.",
+    example: "whiteboard\nline from: 0 0, to: 120 0, style: dotted"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.BAD_VALUE,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Unknown whiteboard value",
+    message: (p) => `Unknown ${s(p.key)}: "${s(p.value)}" \u2014 ${s(p.fallback)} used instead (valid: ${s(p.valid)})${p.hint ? `. ${s(p.hint)}` : ""}`,
+    hint: "Shapes take `fill: solid` or `fill: outline`; arrows take `heads: both`; arrows and lines take `bend:` as a whole number.",
+    example: "whiteboard\nrectangle at: 0 0, size: 100 60, fill: hatched"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.BAD_INK,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Unreadable ink stroke",
+    message: (p) => `Ink stroke skipped \u2014 ${s(p.reason)}`,
+    hint: "An ink line is `ink <colour> <width> <encoded path>`, written by the whiteboard canvas. Do not hand-write or edit the path.",
+    example: "whiteboard\nink red 3 !!!"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.BAD_IMAGE_REF,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Unusable image reference",
+    message: (p) => `Image "${s(p.ref)}" skipped \u2014 an image is a relative path (name.assets/file.webp) or an https:// URL`,
+    hint: "Use a path relative to the diagram, or an https:// link.",
+    example: "whiteboard\nimage ftp://example.com/a.png at: 0 0, size: 320 200"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.EMPTY_TEXT,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Empty text",
+    message: () => "A text line needs some text \u2014 line skipped",
+    hint: "Write the words between `text` and `at:`, or on indented lines under it.",
+    example: "whiteboard\ntext at: 0 0"
+  },
+  {
+    code: WHITEBOARD_DIAGNOSTIC_CODES.UNEXPECTED_BODY,
+    severity: "warning",
+    chartType: "whiteboard",
+    title: "Indented lines under an element with no label",
+    message: (p) => `${s(p.element)} takes no indented lines \u2014 ${s(p.count)} ignored`,
+    hint: "Only shapes, notes, arrows, lines and text have a label that can run over indented lines. Unindent the line if it is meant as its own element.",
+    example: "whiteboard\nimage board.assets/a.webp at: 0 0, size: 320 200\n  caption"
+  }
+];
+var BY_CODE = new Map(WHITEBOARD_DIAGNOSTICS.map((d) => [d.code, d]));
+function whiteboardMessage(code, params) {
+  const msg = BY_CODE.get(code).message;
+  return typeof msg === "string" ? msg : msg(params);
+}
+
+// src/whiteboard/ink-codec.ts
+var INK_DEFAULT_TOLERANCE = 0.75;
+var INK_PRESSURE_LEVELS = 31;
+var FLAG_PRESSURE = 1;
+var FORMAT_VERSION = 0;
+var MAX_DECODED_POINTS = 1e5;
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var B64_INDEX = Object.fromEntries(
+  [...B64].map((c, i) => [c, i])
+);
+function perpDistSq(p, a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) {
+    const ex2 = p.x - a.x;
+    const ey2 = p.y - a.y;
+    return ex2 * ex2 + ey2 * ey2;
+  }
+  let t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / lenSq;
+  t = Math.max(0, Math.min(1, t));
+  const ex = p.x - (a.x + t * dx);
+  const ey = p.y - (a.y + t * dy);
+  return ex * ex + ey * ey;
+}
+function simplify(points, tolerance) {
+  if (points.length <= 2 || tolerance <= 0) return [...points];
+  const keep = new Uint8Array(points.length);
+  keep[0] = 1;
+  keep[points.length - 1] = 1;
+  const tolSq = tolerance * tolerance;
+  const stack = [[0, points.length - 1]];
+  while (stack.length > 0) {
+    const [first, last] = stack.pop();
+    let maxD = 0;
+    let index = -1;
+    for (let i = first + 1; i < last; i++) {
+      const d = perpDistSq(points[i], points[first], points[last]);
+      if (d > maxD) {
+        maxD = d;
+        index = i;
+      }
+    }
+    if (index !== -1 && maxD > tolSq) {
+      keep[index] = 1;
+      stack.push([first, index], [index, last]);
+    }
+  }
+  return points.filter((_, i) => keep[i] === 1);
+}
+function zigzag(n) {
+  return n >= 0 ? n * 2 : -n * 2 - 1;
+}
+function unzigzag(n) {
+  return n % 2 === 0 ? n / 2 : -(n + 1) / 2;
+}
+function pushVarint(out, value) {
+  let v = value;
+  while (v >= 128) {
+    out.push(v % 128 | 128);
+    v = Math.floor(v / 128);
+  }
+  out.push(v);
+}
+function toBase64Url(bytes) {
+  let s2 = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = bytes[i + 1];
+    const b2 = bytes[i + 2];
+    s2 += B64[b0 >> 2];
+    s2 += B64[(b0 & 3) << 4 | (b1 ?? 0) >> 4];
+    if (b1 !== void 0) s2 += B64[(b1 & 15) << 2 | (b2 ?? 0) >> 6];
+    if (b2 !== void 0) s2 += B64[b2 & 63];
+  }
+  return s2;
+}
+function fromBase64Url(s2) {
+  if (s2.length % 4 === 1) return null;
+  const out = [];
+  let buf = 0;
+  let bits = 0;
+  for (const ch of s2) {
+    const v = B64_INDEX[ch];
+    if (v === void 0) return null;
+    buf = buf << 6 | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out.push(buf >> bits & 255);
+    }
+  }
+  return out;
+}
+function encodeInk(points, opts = {}) {
+  const tolerance = opts.tolerance ?? INK_DEFAULT_TOLERANCE;
+  const finite = points.filter(
+    (p) => Number.isFinite(p.x) && Number.isFinite(p.y)
+  );
+  const hasPressure = finite.length > 0 && finite.every((p) => typeof p.pressure === "number" && isFinite(p.pressure));
+  const simplified = simplify(finite, tolerance);
+  const rounded = [];
+  for (const p of simplified) {
+    const x = Math.round(p.x);
+    const y = Math.round(p.y);
+    const prev = rounded[rounded.length - 1];
+    if (prev?.x === x && prev.y === y) continue;
+    rounded.push(
+      hasPressure ? {
+        x,
+        y,
+        pressure: Math.round(
+          Math.max(0, Math.min(1, p.pressure)) * INK_PRESSURE_LEVELS
+        )
+      } : { x, y }
+    );
+  }
+  const bytes = [
+    FORMAT_VERSION << 1 | (hasPressure ? FLAG_PRESSURE : 0)
+  ];
+  let px = 0;
+  let py = 0;
+  let pp = 0;
+  for (const p of rounded) {
+    pushVarint(bytes, zigzag(p.x - px));
+    pushVarint(bytes, zigzag(p.y - py));
+    px = p.x;
+    py = p.y;
+    if (hasPressure) {
+      pushVarint(bytes, zigzag(p.pressure - pp));
+      pp = p.pressure;
+    }
+  }
+  return toBase64Url(bytes);
+}
+function decodeInk(encoded) {
+  const fail = (error) => ({ points: [], error });
+  if (typeof encoded !== "string" || encoded.length === 0) {
+    return fail("empty ink payload");
+  }
+  const bytes = fromBase64Url(encoded);
+  if (!bytes?.length) {
+    return fail("ink payload is not base64url");
+  }
+  const flags = bytes[0];
+  if (flags >> 1 !== FORMAT_VERSION) {
+    return fail(`unknown ink format version ${String(flags >> 1)}`);
+  }
+  const hasPressure = (flags & FLAG_PRESSURE) !== 0;
+  let pos = 1;
+  const readVarint = () => {
+    let result = 0;
+    let mul = 1;
+    for (let i = 0; i < 8; i++) {
+      if (pos >= bytes.length) return null;
+      const b = bytes[pos++];
+      result += (b & 127) * mul;
+      if ((b & 128) === 0) return unzigzag(result);
+      mul *= 128;
+    }
+    return null;
+  };
+  const points = [];
+  let x = 0;
+  let y = 0;
+  let p = 0;
+  while (pos < bytes.length) {
+    const dx = readVarint();
+    const dy = readVarint();
+    const dp = hasPressure ? readVarint() : 0;
+    if (dx === null || dy === null || dp === null) {
+      return fail("ink payload is truncated");
+    }
+    x += dx;
+    y += dy;
+    p += dp;
+    if (hasPressure && (p < 0 || p > INK_PRESSURE_LEVELS)) {
+      return fail("ink pressure out of range");
+    }
+    points.push(
+      hasPressure ? { x, y, pressure: p / INK_PRESSURE_LEVELS } : { x, y }
+    );
+    if (points.length > MAX_DECODED_POINTS) {
+      return fail("ink payload is too long");
+    }
+  }
+  return { points, error: null };
+}
+
+// src/whiteboard/types.ts
+var WHITEBOARD_COLORS = [
+  "ink",
+  "red",
+  "green",
+  "blue",
+  "teal",
+  "purple",
+  "orange",
+  "yellow",
+  "cyan",
+  "gray"
+];
+var WHITEBOARD_SHAPE_KINDS = [
+  "rectangle",
+  "ellipse",
+  "database",
+  "queue"
+];
+var WHITEBOARD_ELEMENT_KEYWORDS = [
+  ...WHITEBOARD_SHAPE_KINDS,
+  "note",
+  "arrow",
+  "line",
+  "text",
+  "image",
+  "ink"
+];
+var WHITEBOARD_STROKE_STYLES = ["solid", "dashed"];
+var WHITEBOARD_FILLS = ["tint", "solid", "outline"];
+var WHITEBOARD_HEADS = ["end", "both"];
+var WHITEBOARD_NOTE_WIDTH = 160;
+var WHITEBOARD_NOTE_HEIGHT = 99;
+var WHITEBOARD_NOTE_COLOR = "yellow";
+function isWhiteboardColor(value) {
+  return WHITEBOARD_COLORS.includes(value);
+}
+function isWhiteboardShapeKind(value) {
+  return WHITEBOARD_SHAPE_KINDS.includes(value);
+}
+
+// src/whiteboard/parser.ts
+var WHITEBOARD_COORD_MAX = 1e6;
+var META_KEY_RE = /(^|\s)([a-z][a-z-]*):(?=\s|$)/;
+var INT_PAIR_RE = /^(-?\d+)\s+(-?\d+)$/;
+var INK_LINE_RE = /^(\S+)\s+(\S+)\s+(\S+)$/;
+var INK_WIDTH_RE = /^\d+(\.\d+)?$/;
+var INK_WIDTH_MAX = 200;
+var WRITTEN_STYLES = ["dashed"];
+var WRITTEN_FILLS = ["solid", "outline"];
+var KEYS_BY_KIND = {
+  shape: ["at", "size", "color", "fill"],
+  note: ["at", "size", "color"],
+  arrow: ["from", "to", "color", "style", "heads", "bend"],
+  line: ["from", "to", "color", "style", "bend"],
+  text: ["at", "color"],
+  image: ["at", "size"]
+};
+function splitLine(rest) {
+  let name;
+  let metaRegion;
+  const q = rest[0];
+  const close = q === '"' || q === "'" ? rest.indexOf(q, 1) : -1;
+  if (close > 0) {
+    name = rest.slice(1, close);
+    metaRegion = rest.slice(close + 1);
+  } else {
+    const m = META_KEY_RE.exec(rest);
+    if (m) {
+      const cut = m.index + m[1].length;
+      name = rest.slice(0, cut).trim();
+      metaRegion = rest.slice(cut);
+    } else {
+      name = rest.trim();
+      metaRegion = "";
+    }
+  }
+  const meta = /* @__PURE__ */ new Map();
+  for (const part of metaRegion.split(",")) {
+    const t = part.trim();
+    if (!t) continue;
+    const colon = t.indexOf(":");
+    if (colon <= 0) {
+      meta.set("", t);
+      continue;
+    }
+    meta.set(t.slice(0, colon).trim().toLowerCase(), t.slice(colon + 1).trim());
+  }
+  return { name: name.trim(), meta };
+}
+function indentOf(raw) {
+  return raw.length - raw.trimStart().length;
+}
+function collectBody(lines, head) {
+  const base = indentOf(lines[head]);
+  const body = [];
+  let end = head;
+  let pendingBlanks = 0;
+  for (let j = head + 1; j < lines.length; j++) {
+    const raw = lines[j];
+    if (!raw.trim()) {
+      pendingBlanks++;
+      continue;
+    }
+    if (indentOf(raw) <= base) break;
+    for (; pendingBlanks > 0; pendingBlanks--) body.push("");
+    body.push(raw.trim());
+    end = j;
+  }
+  return { body, end };
+}
+function joinLabel(inline, body) {
+  const all = inline ? [inline, ...body] : [...body];
+  while (all.length > 0 && all[0] === "") all.shift();
+  while (all.length > 0 && all[all.length - 1] === "") all.pop();
+  return all.join("\n");
+}
+function isWhiteboardImageRef(ref) {
+  if (/^https:\/\/\S+$/i.test(ref)) return true;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(ref)) return false;
+  if (ref.startsWith("/") || ref.startsWith("\\")) return false;
+  return ref.length > 0;
+}
+function parseWhiteboard(content, _palette) {
+  const options = { noTitle: false, noNotes: false };
+  const elements = [];
+  const result = {
+    type: "whiteboard",
+    title: null,
+    titleLineNumber: null,
+    elements,
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const warn = (line, code, params) => {
+    result.diagnostics.push(
+      makeDgmoError(line, whiteboardMessage(code, params), "warning", code)
+    );
+  };
+  if (!content?.trim()) return fail(0, "No content provided");
+  const readColor = (raw, line, fallback = "ink") => {
+    if (raw === void 0) return fallback;
+    const c = raw.trim().toLowerCase();
+    if (isWhiteboardColor(c)) return c;
+    warn(line, WHITEBOARD_DIAGNOSTIC_CODES.UNKNOWN_COLOR, {
+      color: raw,
+      fallback,
+      hint: suggest(c, WHITEBOARD_COLORS) ?? ""
+    });
+    return fallback;
+  };
+  const readStyle = (raw, line) => {
+    if (raw === void 0) return "solid";
+    const v = raw.trim().toLowerCase();
+    if (v === "dashed") return "dashed";
+    warn(line, WHITEBOARD_DIAGNOSTIC_CODES.UNKNOWN_STYLE, {
+      style: raw,
+      hint: suggest(v, WRITTEN_STYLES) ?? ""
+    });
+    return "solid";
+  };
+  const readFill = (raw, line) => {
+    if (raw === void 0) return "tint";
+    const v = raw.trim().toLowerCase();
+    if (v === "solid" || v === "outline") return v;
+    warn(line, WHITEBOARD_DIAGNOSTIC_CODES.BAD_VALUE, {
+      key: "fill",
+      value: raw,
+      fallback: "tint",
+      valid: WRITTEN_FILLS.join(", "),
+      hint: suggest(v, WRITTEN_FILLS) ?? ""
+    });
+    return "tint";
+  };
+  const readHeads = (raw, line) => {
+    if (raw === void 0) return "end";
+    const v = raw.trim().toLowerCase();
+    if (v === "both") return "both";
+    warn(line, WHITEBOARD_DIAGNOSTIC_CODES.BAD_VALUE, {
+      key: "heads",
+      value: raw,
+      fallback: "one head, at to:",
+      valid: "both",
+      hint: suggest(v, ["both"]) ?? ""
+    });
+    return "end";
+  };
+  const readBend = (raw, line) => {
+    if (raw === void 0) return 0;
+    const v = raw.trim();
+    if (/^-?\d+$/.test(v) && Math.abs(Number(v)) <= WHITEBOARD_COORD_MAX) {
+      return Number(v);
+    }
+    warn(line, WHITEBOARD_DIAGNOSTIC_CODES.BAD_VALUE, {
+      key: "bend",
+      value: raw,
+      fallback: "straight",
+      valid: "a whole number of px",
+      hint: ""
+    });
+    return 0;
+  };
+  const readPair = (meta, key, element, line, positive) => {
+    const raw = meta.get(key);
+    const m = raw === void 0 ? null : INT_PAIR_RE.exec(raw);
+    if (!m) {
+      warn(line, WHITEBOARD_DIAGNOSTIC_CODES.BAD_GEOMETRY, {
+        element,
+        need: `${key}: <x> <y> as two whole numbers`,
+        got: raw === void 0 ? `no ${key}:` : `"${raw}"`
+      });
+      return null;
+    }
+    const a = Number(m[1]);
+    const b = Number(m[2]);
+    const bad = (v) => Math.abs(v) > WHITEBOARD_COORD_MAX || positive && v < 1;
+    if (bad(a) || bad(b)) {
+      warn(line, WHITEBOARD_DIAGNOSTIC_CODES.OUT_OF_RANGE, {
+        key,
+        raw,
+        max: WHITEBOARD_COORD_MAX
+      });
+      return null;
+    }
+    return [a, b];
+  };
+  const checkKeys = (meta, kind, element, line) => {
+    const valid = KEYS_BY_KIND[kind];
+    for (const key of meta.keys()) {
+      if (key === "" || valid.includes(key)) continue;
+      warn(line, WHITEBOARD_DIAGNOSTIC_CODES.UNKNOWN_KEY, {
+        key,
+        element,
+        valid: valid.map((k) => `${k}:`).join(", "),
+        hint: suggest(key, valid) ?? ""
+      });
+    }
+  };
+  const lines = content.split("\n");
+  let firstLineSeen = false;
+  for (let i = 0; i < lines.length; i++) {
+    const lineNumber = i + 1;
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (!firstLineSeen) {
+      firstLineSeen = true;
+      const first = parseFirstLine(trimmed);
+      if (first?.chartType !== "whiteboard") {
+        let msg = `Expected chart type "whiteboard", got "${first?.chartType ?? trimmed.split(/\s+/)[0]}"`;
+        const hint = suggest(first?.chartType ?? "", ["whiteboard"]);
+        if (hint) msg += `. ${hint}`;
+        return fail(lineNumber, msg);
+      }
+      result.title = first.title ?? null;
+      result.titleLineNumber = lineNumber;
+      continue;
+    }
+    const shared = recognizeGlobalBoolean(trimmed);
+    if (shared !== null) {
+      if (shared === "no-title") options.noTitle = true;
+      if (shared === "no-notes") options.noNotes = true;
+      continue;
+    }
+    const sp = trimmed.search(/\s/);
+    const word = (sp === -1 ? trimmed : trimmed.slice(0, sp)).toLowerCase();
+    const rest = sp === -1 ? "" : trimmed.slice(sp + 1).trim();
+    const { body, end } = collectBody(lines, i);
+    i = end;
+    const noBody = (element) => {
+      if (body.length > 0) {
+        warn(lineNumber, WHITEBOARD_DIAGNOSTIC_CODES.UNEXPECTED_BODY, {
+          element,
+          count: body.filter((b) => b !== "").length
+        });
+      }
+    };
+    if (word === "ink") {
+      noBody("ink");
+      const m = INK_LINE_RE.exec(rest);
+      if (!m) {
+        warn(lineNumber, WHITEBOARD_DIAGNOSTIC_CODES.BAD_INK, {
+          reason: "expected `ink <colour> <width> <encoded path>`"
+        });
+        continue;
+      }
+      const color = readColor(m[1], lineNumber);
+      const widthRaw = m[2];
+      const width = Number(widthRaw);
+      if (!INK_WIDTH_RE.test(widthRaw) || width <= 0 || width > INK_WIDTH_MAX) {
+        warn(lineNumber, WHITEBOARD_DIAGNOSTIC_CODES.BAD_INK, {
+          reason: `width "${widthRaw}" must be a number above 0 and at most ${INK_WIDTH_MAX}`
+        });
+        continue;
+      }
+      const decoded = decodeInk(m[3]);
+      if (decoded.error !== null || decoded.points.length === 0) {
+        warn(lineNumber, WHITEBOARD_DIAGNOSTIC_CODES.BAD_INK, {
+          reason: decoded.error ?? "the stroke has no points"
+        });
+        continue;
+      }
+      if (decoded.points.some(
+        (p) => Math.abs(p.x) > WHITEBOARD_COORD_MAX || Math.abs(p.y) > WHITEBOARD_COORD_MAX
+      )) {
+        warn(lineNumber, WHITEBOARD_DIAGNOSTIC_CODES.BAD_INK, {
+          reason: `a point lies beyond \xB1${WHITEBOARD_COORD_MAX} px`
+        });
+        continue;
+      }
+      elements.push({
+        kind: "ink",
+        color,
+        width,
+        encoded: m[3],
+        points: decoded.points,
+        lineNumber
+      });
+      continue;
+    }
+    if (isWhiteboardShapeKind(word)) {
+      const { name, meta } = splitLine(rest);
+      checkKeys(meta, "shape", word, lineNumber);
+      const at = readPair(meta, "at", word, lineNumber, false);
+      if (!at) continue;
+      const size = readPair(meta, "size", word, lineNumber, true);
+      if (!size) continue;
+      elements.push({
+        kind: "shape",
+        shape: word,
+        x: at[0],
+        y: at[1],
+        width: size[0],
+        height: size[1],
+        label: joinLabel(name, body),
+        color: readColor(meta.get("color"), lineNumber),
+        fill: readFill(meta.get("fill"), lineNumber),
+        lineNumber
+      });
+      continue;
+    }
+    if (word === "note") {
+      const { name, meta } = splitLine(rest);
+      checkKeys(meta, "note", "note", lineNumber);
+      const at = readPair(meta, "at", "note", lineNumber, false);
+      if (!at) continue;
+      const size = meta.has("size") ? readPair(meta, "size", "note", lineNumber, true) : [WHITEBOARD_NOTE_WIDTH, WHITEBOARD_NOTE_HEIGHT];
+      if (!size) continue;
+      elements.push({
+        kind: "note",
+        x: at[0],
+        y: at[1],
+        width: size[0],
+        height: size[1],
+        text: joinLabel(name, body),
+        color: readColor(meta.get("color"), lineNumber, WHITEBOARD_NOTE_COLOR),
+        lineNumber
+      });
+      continue;
+    }
+    if (word === "arrow" || word === "line") {
+      const { name, meta } = splitLine(rest);
+      checkKeys(meta, word, word, lineNumber);
+      const from = readPair(meta, "from", word, lineNumber, false);
+      if (!from) continue;
+      const to = readPair(meta, "to", word, lineNumber, false);
+      if (!to) continue;
+      const common = {
+        x1: from[0],
+        y1: from[1],
+        x2: to[0],
+        y2: to[1],
+        label: joinLabel(name, body),
+        color: readColor(meta.get("color"), lineNumber),
+        style: readStyle(meta.get("style"), lineNumber),
+        bend: readBend(meta.get("bend"), lineNumber),
+        lineNumber
+      };
+      elements.push(
+        word === "arrow" ? {
+          kind: "arrow",
+          ...common,
+          heads: readHeads(meta.get("heads"), lineNumber)
+        } : { kind: "line", ...common }
+      );
+      continue;
+    }
+    if (word === "text") {
+      const { name, meta } = splitLine(rest);
+      checkKeys(meta, "text", "text", lineNumber);
+      const text = joinLabel(name, body);
+      if (!text) {
+        warn(lineNumber, WHITEBOARD_DIAGNOSTIC_CODES.EMPTY_TEXT, {});
+        continue;
+      }
+      const at = readPair(meta, "at", "text", lineNumber, false);
+      if (!at) continue;
+      elements.push({
+        kind: "text",
+        x: at[0],
+        y: at[1],
+        text,
+        color: readColor(meta.get("color"), lineNumber),
+        lineNumber
+      });
+      continue;
+    }
+    if (word === "image") {
+      const { name, meta } = splitLine(rest);
+      checkKeys(meta, "image", "image", lineNumber);
+      noBody("image");
+      if (!isWhiteboardImageRef(name)) {
+        warn(lineNumber, WHITEBOARD_DIAGNOSTIC_CODES.BAD_IMAGE_REF, { ref: name });
+        continue;
+      }
+      const at = readPair(meta, "at", "image", lineNumber, false);
+      if (!at) continue;
+      const size = readPair(meta, "size", "image", lineNumber, true);
+      if (!size) continue;
+      elements.push({
+        kind: "image",
+        ref: name,
+        x: at[0],
+        y: at[1],
+        width: size[0],
+        height: size[1],
+        lineNumber
+      });
+      continue;
+    }
+    warn(lineNumber, WHITEBOARD_DIAGNOSTIC_CODES.UNKNOWN_ELEMENT, {
+      word,
+      hint: suggest(word, WHITEBOARD_ELEMENT_KEYWORDS) ?? ""
+    });
+  }
+  if (!firstLineSeen) return fail(0, "No content provided");
+  return result;
+}
+
+export {
+  WHITEBOARD_DIAGNOSTICS,
+  INK_DEFAULT_TOLERANCE,
+  INK_PRESSURE_LEVELS,
+  encodeInk,
+  decodeInk,
+  WHITEBOARD_COLORS,
+  WHITEBOARD_SHAPE_KINDS,
+  WHITEBOARD_ELEMENT_KEYWORDS,
+  WHITEBOARD_STROKE_STYLES,
+  WHITEBOARD_FILLS,
+  WHITEBOARD_HEADS,
+  WHITEBOARD_NOTE_WIDTH,
+  WHITEBOARD_NOTE_HEIGHT,
+  WHITEBOARD_NOTE_COLOR,
+  isWhiteboardColor,
+  isWhiteboardShapeKind,
+  isWhiteboardImageRef,
+  parseWhiteboard
+};