@draftably/markdown 0.1.0 → 0.2.1

package/dist/markdown-it.js

@@ -1,155 +1,156 @@
-import { m as T, p as S, i as P, a as I, h as F } from "./chunks/core-DPjuIyPG.js";
-import { p as j } from "./chunks/metadata-Dx6T_2Zy.js";
-function x(t) {
+import { m as I, a as T, p as F, i as j, b as x, h as H } from "./chunks/core-D4HpamVq.js";
+import { p as O } from "./chunks/metadata-Dx6T_2Zy.js";
+function R(t) {
   return /^draft(?:\s|$)/.test(t.trim());
 }
-function E(t) {
+function M(t) {
   return t.replace(
     /[&<>"']/g,
-    (r) => ({
+    (e) => ({
       "&": "&amp;",
       "<": "&lt;",
       ">": "&gt;",
       '"': "&quot;",
       "'": "&#39;"
-    })[r]
+    })[e]
   );
 }
-function H(t) {
-  const r = `${t.width === void 0 ? "" : ` width="${t.width}"`}${t.height === void 0 ? "" : ` height="${t.height}"`}`;
-  return `<img src="${E(t.url)}" alt="${E(t.alt)}"${r}>`;
+function _(t) {
+  const e = `${t.width === void 0 ? "" : ` width="${t.width}"`}${t.height === void 0 ? "" : ` height="${t.height}"`}`;
+  return `<img src="${M(t.url)}" alt="${M(t.alt)}"${e}>`;
 }
-function A(t, r) {
-  const d = t.type;
-  if (d === "paragraph") {
-    const e = t.data?.hProperties ?? {}, l = typeof e.id == "string" ? ` id="${r(e.id)}"` : "", a = t.children.map((o) => A(o, r)).join("");
-    return `<p${l}>${a}</p>
+function A(t, e) {
+  const c = t.type;
+  if (c === "paragraph") {
+    const r = t.data?.hProperties ?? {}, f = typeof r.id == "string" ? ` id="${e(r.id)}"` : "", o = t.children.map((s) => A(s, e)).join("");
+    return `<p${f}>${o}</p>
 `;
   }
-  if (d === "figure") {
-    const l = t.data?.hProperties?.id, h = typeof l == "string" ? ` id="${r(l)}"` : "", a = t.children;
-    return `<figure${h}>${a.map((o) => A(o, r)).join("")}</figure>
+  if (c === "figure") {
+    const f = t.data?.hProperties?.id, h = typeof f == "string" ? ` id="${e(f)}"` : "", o = t.children;
+    return `<figure${h}>${o.map((s) => A(s, e)).join("")}</figure>
 `;
   }
-  if (d === "image") {
-    const e = t.data?.hProperties ?? {};
-    return H({
+  if (c === "image") {
+    const r = t.data?.hProperties ?? {};
+    return _({
       url: String(t.url ?? ""),
       alt: String(t.alt ?? ""),
-      ...typeof e.width == "number" ? { width: e.width } : {},
-      ...typeof e.height == "number" ? { height: e.height } : {}
+      ...typeof r.width == "number" ? { width: r.width } : {},
+      ...typeof r.height == "number" ? { height: r.height } : {}
     });
   }
-  if (d === "figcaption")
-    return `<figcaption>${t.children.map((l) => A(l, r)).join("")}</figcaption>`;
-  if (d === "div") {
-    const e = t.data?.hProperties ?? {};
-    if (!(e["data-draftably-region"] === "") || typeof e["data-draftably-init"] != "string" || typeof e["data-draftably-policy"] != "string" || typeof e["data-draftably-key"] != "string")
+  if (c === "figcaption")
+    return `<figcaption>${t.children.map((f) => A(f, e)).join("")}</figcaption>`;
+  if (c === "div") {
+    const r = t.data?.hProperties ?? {};
+    if (!(r["data-draftably-region"] === "") || typeof r["data-draftably-init"] != "string" || typeof r["data-draftably-policy"] != "string" || typeof r["data-draftably-key"] != "string")
       throw new Error("Invalid generated viewer region.");
-    const h = typeof e["aria-label"] == "string" ? e["aria-label"] : "Diagram viewer";
-    return `<div class="draftably-viewer-region" data-draftably-region="" data-draftably-init="${r(String(e["data-draftably-init"]))}" data-draftably-policy="${r(String(e["data-draftably-policy"]))}" data-draftably-key="${r(String(e["data-draftably-key"]))}" role="region" aria-label="${r(h)}"></div>`;
+    const h = typeof r["aria-label"] == "string" ? r["aria-label"] : "Diagram viewer";
+    return `<div class="draftably-viewer-region" data-draftably-region="" data-draftably-init="${e(String(r["data-draftably-init"]))}" data-draftably-policy="${e(String(r["data-draftably-policy"]))}" data-draftably-key="${e(String(r["data-draftably-key"]))}" role="region" aria-label="${e(h)}"></div>`;
   }
-  if (d === "text") return r(String(t.value ?? ""));
-  throw new Error(`Unsupported generated AST node: ${String(d)}.`);
+  if (c === "text") return e(String(t.value ?? ""));
+  throw new Error(`Unsupported generated AST node: ${String(c)}.`);
 }
-function _(t) {
+function B(t) {
   if (!t || typeof t.emitAsset != "function")
     throw new TypeError("createMarkdownItDraft requires an emitAsset function.");
-  const r = /* @__PURE__ */ new WeakMap(), d = (a) => a.type === "fence" && x(a.info ?? "");
-  function e(a) {
-    const o = a, p = o.renderer.rules.fence;
-    o.renderer.rules.fence = function(c, u, g, y, b) {
-      const $ = c[u];
-      if (!d($))
-        return p ? p(c, u, g, y, b) : b.renderToken(c, u, g);
-      const D = r.get($);
-      if (!D)
+  const e = /* @__PURE__ */ new WeakMap(), c = (o) => o.type === "fence" && R(o.info ?? "");
+  function r(o) {
+    const s = o, l = s.renderer.rules.fence;
+    s.renderer.rules.fence = function(d, p, y, g, b) {
+      const $ = d[p];
+      if (!c($) && !e.has($))
+        return l ? l(d, p, y, g, b) : b.renderToken(d, p, y);
+      const v = e.get($);
+      if (!v)
         throw new Error(
           "Draft fence rendered before prepare(). Prepare and render the same token tree."
         );
-      return A(D.node, (k) => o.utils.escapeHtml(k));
+      return A(v.node, (k) => s.utils.escapeHtml(k));
     };
   }
-  async function l(a, o, p = {}) {
-    const c = a.parse(o, p), u = await h(c, p);
-    return { html: a.renderer.render(c, a.options, p), manifest: u };
+  async function f(o, s, l = {}) {
+    const d = o.parse(s, l), p = await h(d, l);
+    return { html: o.renderer.render(d, o.options, l), manifest: p };
   }
-  async function h(a, o = {}) {
-    const p = { path: o.draftably?.documentPath }, c = [], u = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Set(), y = [], b = /* @__PURE__ */ new Set(), $ = t.sources && {
+  async function h(o, s = {}) {
+    const l = { path: s.draftably?.documentPath }, d = [], p = /* @__PURE__ */ new Set(), y = /* @__PURE__ */ new Set(), g = [], b = /* @__PURE__ */ new Set(), $ = t.sources && {
       ...t.sources,
-      onDependency: (w) => {
-        u.add(w.dependencyPath);
+      onDependency: (m) => {
+        p.add(m.dependencyPath);
         try {
-          t.sources?.onDependency?.(w);
-        } catch (s) {
-          throw F(s, "Markdown dependency callback failed.");
+          t.sources?.onDependency?.(m);
+        } catch (a) {
+          throw H(a, "Markdown dependency callback failed.");
         }
       }
     };
-    let D = 0;
-    const k = async (w) => {
-      for (const s of w) {
-        if (d(s)) {
-          const M = D++, v = { sourceId: p.path, line: (s.map?.[0] ?? 0) + 1 };
-          r.delete(s);
+    let v = 0;
+    const k = async (m) => {
+      for (const a of m) {
+        const D = { sourceId: l.path, line: (a.map?.[0] ?? 0) + 1 }, w = a.type === "fence" && /^mermaid(?:\s|$)/.test((a.info ?? "").trim()) ? await I(a.content ?? "", D, t) : void 0;
+        if (g.push(...w?.diagnostics ?? []), w && e.delete(a), c(a) || w?.source) {
+          const P = v++;
+          e.delete(a);
           try {
             let n;
             try {
-              n = j(s.info ?? "");
-            } catch (f) {
-              const m = f instanceof Error ? f.message : "Invalid draft fence metadata.";
-              throw Object.assign(new Error(m), {
-                diagnostic: T("DRAFT_METADATA", m, v)
+              n = w ? { alt: w.alt } : O(a.info ?? "");
+            } catch (u) {
+              const E = u instanceof Error ? u.message : "Invalid draft fence metadata.";
+              throw Object.assign(new Error(E), {
+                diagnostic: T("DRAFT_METADATA", E, D)
               });
             }
             if (n.id && b.has(n.id)) {
-              const f = `Duplicate draft id "${n.id}" in this document.`;
-              throw Object.assign(new Error(f), {
-                diagnostic: T("DRAFT_METADATA", f, v)
+              const u = `Duplicate draft id "${n.id}" in this document.`;
+              throw Object.assign(new Error(u), {
+                diagnostic: T("DRAFT_METADATA", u, D)
               });
             }
             n.id && b.add(n.id);
-            const i = await S(s.content ?? "", n, v, p, M, {
+            const S = w?.source ?? a.content ?? "", i = await F(S, n, D, l, P, {
               ...t,
               sources: $
             });
-            r.set(s, { node: i.node, diagnostics: i.diagnostics }), i.asset && c.push(i.asset), c.push(...i.extraAssets ?? []), i.dependency && u.add(i.dependency), i.clientModule && g.add(i.clientModule), y.push(...i.diagnostics);
+            e.set(a, { node: i.node, diagnostics: i.diagnostics }), i.asset && d.push(i.asset), d.push(...i.extraAssets ?? []), i.dependency && p.add(i.dependency), i.clientModule && y.add(i.clientModule), g.push(...i.diagnostics);
           } catch (n) {
-            if (P(n)) throw n.cause ?? n;
-            if (I(n)) throw n;
-            const i = n.diagnostic, f = n.diagnostics, m = i ?? f?.[0] ?? T(
+            if (j(n)) throw n.cause ?? n;
+            if (x(n)) throw n;
+            const S = n.diagnostic, i = n.diagnostics, u = S ?? i?.[0] ?? T(
               "DRAFT_BUILD",
               n instanceof Error ? n.message : "Could not prepare diagram.",
-              v
+              D
             );
-            if (y.push(...f ?? [m]), (t.errors ?? "fail") === "fail")
+            if (g.push(...i ?? [u]), (t.errors ?? "fail") === "fail")
               throw Object.assign(new Error("Draftably Markdown preparation failed."), {
-                diagnostics: f ?? [m]
+                diagnostics: i ?? [u]
               });
-            r.set(s, {
+            e.set(a, {
               node: {
                 type: "paragraph",
                 children: [{ type: "text", value: "Diagram unavailable." }]
               },
-              diagnostics: f ?? [m]
+              diagnostics: i ?? [u]
             });
           }
         }
-        s.children?.length && await k(s.children);
+        a.children?.length && await k(a.children);
       }
     };
-    await k(a);
-    for (const w of y) t.onDiagnostic?.(w);
+    await k(o);
+    for (const m of g) t.onDiagnostic?.(m);
     return {
       version: 1,
-      assets: c,
-      clientModules: [...g],
-      dependencies: [...u],
-      diagnostics: y
+      assets: d,
+      clientModules: [...y],
+      dependencies: [...p],
+      diagnostics: g
     };
   }
-  return { plugin: e, prepare: h, render: l };
+  return { plugin: r, prepare: h, render: f };
 }
 export {
-  _ as createMarkdownItDraft
+  B as createMarkdownItDraft
 };

package/dist/mermaid.js

@@ -0,0 +1,93 @@
+import { isMainThread as y, workerData as b, parentPort as g, Worker as v } from "node:worker_threads";
+const k = /^(?:flowchart|graph|sequenceDiagram)\b/;
+function D(i) {
+  const s = i.replace(/^\uFEFF/, "").split(`
+`);
+  let e = 0;
+  if (s[0]?.trim() === "---" && (e = s.findIndex((t, r) => r > 0 && t.trim() === "---") + 1, e === 0))
+    return !1;
+  for (; e < s.length; e++) {
+    const t = s[e].trim();
+    if (!(!t || t.startsWith("%%")))
+      return k.test(t);
+  }
+  return !1;
+}
+let f, F = 0;
+const n = /* @__PURE__ */ new Map();
+function T() {
+  const i = new v(new URL(import.meta.url), {
+    workerData: { kind: "draftably-mermaid" },
+    resourceLimits: { maxOldGenerationSizeMb: 512, stackSizeMb: 4 }
+  });
+  i.unref();
+  const s = (e) => {
+    f = void 0;
+    for (const [t, r] of n) r({ id: t, messages: [e] });
+    n.clear();
+  };
+  return i.on("message", (e) => {
+    n.get(e.id)?.(e), n.delete(e.id);
+  }), i.on("error", (e) => s(`Mermaid parser failed: ${e.message}`)), i.on("exit", (e) => s(`Mermaid parser stopped with status ${e}.`)), i;
+}
+async function I(i, s) {
+  if (!D(i)) return { source: null, diagnostics: [] };
+  f ??= T();
+  const e = F++, t = f, r = await new Promise((o) => {
+    const d = setTimeout(() => {
+      n.delete(e), t.terminate(), o({ id: e, messages: ["Mermaid parsing timed out."] });
+    }, 3e4);
+    n.set(e, (c) => {
+      clearTimeout(d), o(c);
+    }), t.ref(), t.postMessage({ id: e, text: i });
+  }).finally(() => {
+    n.size || t.unref();
+  });
+  return {
+    source: r.source ?? null,
+    alt: r.alt,
+    diagnostics: r.source ? [] : [
+      {
+        code: "DRAFT_MERMAID",
+        severity: "warning",
+        message: `Left this Mermaid fence to Mermaid: ${r.messages.join(" ") || "it could not be converted."}`,
+        location: s,
+        itemIds: []
+      }
+    ]
+  };
+}
+async function S() {
+  globalThis.fetch = async () => {
+    throw Error("Mermaid resource loading is disabled.");
+  };
+  const { JSDOM: i } = await import("jsdom"), { createMermaidFlowParser: s, makePlainLabel: e } = await import("./chunks/mermaid-facade-BoLWBerE.js"), { importMermaidFlow: t } = await import("./chunks/mermaid-importer-D9i_Vfxl.js"), r = new i("<!doctype html><html><body></body></html>", {
+    url: "https://import.invalid/"
+  });
+  Object.assign(globalThis, {
+    window: r.window,
+    document: r.window.document,
+    Option: r.window.Option
+  });
+  const o = s(async () => (await import("mermaid")).default), d = e(r.window.document);
+  g.on("message", async ({ id: c, text: h }) => {
+    let m;
+    try {
+      const a = await o(h), l = a.ok ? a.snapshot : void 0, p = l?.family === "sequence" ? l.title ?? "" : "", M = p || (l?.family === "sequence" ? "Sequence diagram" : "Flowchart"), w = t(a, d, p);
+      m = {
+        id: c,
+        source: w.nativeSource,
+        alt: M,
+        messages: w.diagnostics.filter((u) => u.severity === "error").map((u) => u.message)
+      };
+    } catch (a) {
+      m = { id: c, messages: [a instanceof Error ? a.message : String(a)] };
+    }
+    g.postMessage(m);
+  });
+}
+!y && b?.kind === "draftably-mermaid" && S();
+export {
+  I as convertMermaid,
+  D as isMermaidCandidate
+};

package/dist/remark.js

@@ -1,86 +1,86 @@
-import { m as h, p as b, i as k, a as v, h as F } from "./chunks/core-DPjuIyPG.js";
-import { p as x } from "./chunks/metadata-Dx6T_2Zy.js";
-function j(s) {
+import { m as T, a as g, p as k, i as F, b as x, h as O } from "./chunks/core-D4HpamVq.js";
+import { p as I } from "./chunks/metadata-Dx6T_2Zy.js";
+function R(s) {
   if (!s || typeof s.emitAsset != "function")
     throw new TypeError("remarkDraft requires an emitAsset function.");
-  return async (D, d) => {
-    const A = { path: d.path }, u = [], m = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Set(), E = s.sources && {
+  return async (A, f) => {
+    const b = { path: f.path }, m = [], w = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Set(), v = s.sources && {
       ...s.sources,
       onDependency: (i) => {
         p.add(i.dependencyPath);
         try {
           s.sources?.onDependency?.(i);
         } catch (r) {
-          throw F(r, "Markdown dependency callback failed.");
+          throw O(r, "Markdown dependency callback failed.");
         }
       }
-    }, l = [], g = /* @__PURE__ */ new Set();
-    let M = 0;
-    async function w(i) {
+    }, o = [], y = /* @__PURE__ */ new Set();
+    let E = 0;
+    async function D(i) {
       const r = i.children;
       if (r)
-        for (let o = 0; o < r.length; o++) {
-          const n = r[o];
-          if (n.type === "code" && n.lang === "draft") {
-            const T = M++, f = {
-              sourceId: d.path,
-              line: n.position?.start?.line ?? 1,
-              column: n.position?.start?.column
-            };
+        for (let c = 0; c < r.length; c++) {
+          const t = r[c], d = {
+            sourceId: f.path,
+            line: t.position?.start?.line ?? 1,
+            column: t.position?.start?.column
+          }, l = t.type === "code" && t.lang === "mermaid" ? await T(t.value ?? "", d, s) : void 0;
+          if (o.push(...l?.diagnostics ?? []), t.type === "code" && t.lang === "draft" || l?.source) {
+            const M = E++;
             try {
               let e;
               try {
-                e = x(n.meta ? `draft ${n.meta}` : "draft");
-              } catch (a) {
-                const c = a instanceof Error ? a.message : "Invalid draft fence metadata.";
-                throw Object.assign(new Error(c), {
-                  diagnostic: h("DRAFT_METADATA", c, f)
+                e = l ? { alt: l.alt } : I(t.meta ? `draft ${t.meta}` : "draft");
+              } catch (n) {
+                const u = n instanceof Error ? n.message : "Invalid draft fence metadata.";
+                throw Object.assign(new Error(u), {
+                  diagnostic: g("DRAFT_METADATA", u, d)
                 });
               }
-              if (e.id && g.has(e.id)) {
-                const a = `Duplicate draft id "${e.id}" in this document.`;
-                throw Object.assign(new Error(a), {
-                  diagnostic: h("DRAFT_METADATA", a, f)
+              if (e.id && y.has(e.id)) {
+                const n = `Duplicate draft id "${e.id}" in this document.`;
+                throw Object.assign(new Error(n), {
+                  diagnostic: g("DRAFT_METADATA", n, d)
                 });
               }
-              e.id && g.add(e.id);
-              const t = await b(n.value ?? "", e, f, A, T, {
+              e.id && y.add(e.id);
+              const h = l?.source ?? t.value ?? "", a = await k(h, e, d, b, M, {
                 ...s,
-                sources: E
+                sources: v
               });
-              r.splice(o, 1, t.node), t.asset && u.push(t.asset), u.push(...t.extraAssets ?? []), t.clientModule && m.add(t.clientModule), t.dependency && p.add(t.dependency), l.push(...t.diagnostics);
+              r.splice(c, 1, a.node), a.asset && m.push(a.asset), m.push(...a.extraAssets ?? []), a.clientModule && w.add(a.clientModule), a.dependency && p.add(a.dependency), o.push(...a.diagnostics);
             } catch (e) {
-              if (k(e)) throw e.cause ?? e;
-              if (v(e)) throw e;
-              const t = e.diagnostic, a = e.diagnostics, c = t ?? a?.[0] ?? h(
+              if (F(e)) throw e.cause ?? e;
+              if (x(e)) throw e;
+              const h = e.diagnostic, a = e.diagnostics, n = h ?? a?.[0] ?? g(
                 "DRAFT_BUILD",
                 e instanceof Error ? e.message : "Could not prepare diagram.",
-                f
+                d
               );
-              if (l.push(...a ?? [c]), (s.errors ?? "fail") === "fail") {
-                const y = new Error("Draftably Markdown transform failed.");
-                throw Object.assign(y, { diagnostics: a ?? [c] }), y;
+              if (o.push(...a ?? [n]), (s.errors ?? "fail") === "fail") {
+                const u = new Error("Draftably Markdown transform failed.");
+                throw Object.assign(u, { diagnostics: a ?? [n] }), u;
               }
-              r.splice(o, 1, {
+              r.splice(c, 1, {
                 type: "paragraph",
                 children: [{ type: "text", value: "Diagram unavailable." }]
               });
             }
           } else
-            await w(n);
+            await D(t);
         }
     }
-    await w(D);
-    for (const i of l) s.onDiagnostic?.(i);
-    d.data ??= {}, d.data.draftably = {
+    await D(A);
+    for (const i of o) s.onDiagnostic?.(i);
+    f.data ??= {}, f.data.draftably = {
       version: 1,
-      assets: u,
-      clientModules: [...m],
+      assets: m,
+      clientModules: [...w],
       dependencies: [...p],
-      diagnostics: l
+      diagnostics: o
     };
   };
 }
 export {
-  j as default
+  R as default
 };

package/dist/types/{core.d.ts → packages/markdown/src/core.d.ts}

@@ -37,6 +37,11 @@ export type EmitAsset = (asset: DraftAsset, context: {
 export interface DraftMarkdownOptions {
     emitAsset: EmitAsset;
     errors?: 'fail' | 'placeholder';
+    /**
+     * `convert` draws ```mermaid fences that hold a flowchart or sequence as Draftably images and
+     * leaves every other Mermaid family as a code block. `off` (default) leaves all of them.
+     */
+    mermaid?: 'convert' | 'off';
     interactive?: MarkdownInteractiveBridge;
     render?: {
         includeSource?: boolean;
@@ -84,6 +89,12 @@ export interface MarkdownInteractiveBridge {
         url: string;
     }>;
 }
+/** Native source for a Mermaid fence, or null when the fence stays as code. */
+export declare function mermaidSource(text: string, location: Diagnostic['location'], options: DraftMarkdownOptions): Promise<{
+    source: string | null;
+    alt?: string;
+    diagnostics: Diagnostic[];
+}>;
 export declare function makeDiagnostic(code: string, message: string, location?: Diagnostic['location'], related?: Diagnostic['related']): Diagnostic;
 export declare function contentHash(value: string | Uint8Array): string;
 export declare function hostFailure(error: unknown, message?: string): Error;

package/dist/types/packages/markdown/src/mermaid.d.ts

@@ -0,0 +1,8 @@
+import type { Diagnostic } from '@draftably/runtime';
+export declare function isMermaidCandidate(text: string): boolean;
+/** Native source for a Mermaid flowchart or sequence, or null to leave the fence to Mermaid. */
+export declare function convertMermaid(text: string, location: Diagnostic['location']): Promise<{
+    source: string | null;
+    alt?: string;
+    diagnostics: Diagnostic[];
+}>;

package/dist/types/{remark.d.ts → packages/markdown/src/remark.d.ts}

@@ -16,6 +16,6 @@ interface FileLike {
     path?: string;
     data?: Record<string, unknown>;
 }
-/** Convert only parser-recognized `draft` code nodes into static image nodes. */
+/** Convert parser-recognized `draft` code nodes, and opted-in Mermaid ones, into static image nodes. */
 export default function remarkDraft(options: DraftMarkdownOptions): (tree: Node, file: FileLike) => Promise<void>;
 export {};

package/dist/types/src/dsl/cells.d.ts

@@ -0,0 +1,91 @@
+import type { ResolvedAppearance } from '../model/appearance';
+/** Width of a marker's bar, centred on the seam it marks. */
+export declare const MARKER_WIDTH = 8;
+/** How far a marker's bar runs past the cells, so a line meets it clear of their corners. */
+export declare const MARKER_TAIL = 16;
+/** Height of a cells group's title band for a title type of this line height. */
+export declare const cellsBandFor: (lineHeight: number) => number;
+export interface CellInput {
+    id: string;
+    label: string;
+    marker: boolean;
+    /** Columns the cell covers in a grid. */
+    span?: number;
+    /** From a `size` line. */
+    size?: {
+        width: number;
+        height?: number;
+    };
+}
+export interface CellBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** A cell's own size: one line of title when it fits in `MAX_CELL`, wrapped when it does not. */
+export declare function cellSize(c: CellInput, look: ResolvedAppearance): {
+    w: number;
+    h: number;
+};
+/**
+ * Cells edge to edge, in rows of `columns` columns filled in order; a cell's `span` covers that
+ * many columns, and a cell that does not fit the rest of a row starts the next one. Without
+ * `columns`, the cells form one row (`right`) or one column (`down`). Each column is as wide as
+ * its widest single cell, widened at its last column for a wider spanning cell, and each row is
+ * as tall as its tallest cell. Cells narrower than `minWidth` in all, the title band's width,
+ * widen the last column.
+ *
+ * A marker takes no room: in one row or column, its bar sits on the seam before the next cell
+ * and spans the band above as well, so it cuts the whole object, and runs a short tail past the
+ * cells where lines meet it.
+ */
+export declare function layoutCells(cells: CellInput[], shape: {
+    direction: 'right' | 'down';
+    columns?: number;
+}, look: ResolvedAppearance, minWidth?: number): {
+    boxes: Map<string, CellBox>;
+    w: number;
+    h: number;
+};
+/** Width of one unit of a byte or bit layout, and the units in each row, unless the file says. */
+export declare const UNIT_WIDTH: {
+    readonly bit: 24;
+    readonly byte: 48;
+};
+export declare const UNIT_COLUMNS: {
+    readonly bit: 32;
+    readonly byte: 16;
+};
+export interface UnitCells {
+    /** Each field's main box: the longest piece, which holds its title. */
+    boxes: Map<string, CellBox>;
+    /** The other pieces of a field that runs on past a row's end. */
+    pieces: Map<string, CellBox[]>;
+    /** Fields of variable length, drawn with broken ends. */
+    open: string[];
+    /** Unit numbers above the first row: their centres, and the room they take above the cells. */
+    ruler?: {
+        h: number;
+        ticks: Array<{
+            x: number;
+            label: string;
+        }>;
+    };
+    w: number;
+    h: number;
+}
+/**
+ * A byte or bit layout: every unit has one width, so a field's width is its size. Rows hold
+ * `columns` units. A field longer than the rest of its row runs on into the next rows; a field of
+ * variable length (`span: 'var'`) fills the rest of its row, or a whole row, with broken ends.
+ * Every row has the height of the tallest title.
+ */
+export declare function layoutUnits(cells: Array<CellInput & {
+    open?: boolean;
+}>, shape: {
+    unit: 'bit' | 'byte';
+    columns?: number;
+    unitWidth?: number;
+    ruler: boolean;
+}, look: ResolvedAppearance): UnitCells;