@draftably/markdown 0.0.0-stage → 0.2.0

package/dist/chunks/metadata-Dx6T_2Zy.js

@@ -0,0 +1,53 @@
+function w(a) {
+  const n = a.charCodeAt(0);
+  return n < 32 || n === 127;
+}
+function f(a) {
+  const n = /^draft(?:\s+\{([\s\S]*)\})?$/.exec(a.trim());
+  if (!n)
+    throw new Error('Expected the canonical draft fence, optionally followed by {key="value"}.');
+  const r = n[1];
+  if (r === void 0) return {};
+  const t = {};
+  let e = 0;
+  const i = () => {
+    for (; /\s/.test(r[e] ?? "") && e < r.length; ) e++;
+  };
+  for (; e < r.length && (i(), e !== r.length); ) {
+    const o = /^[A-Za-z][A-Za-z0-9_-]*/.exec(r.slice(e))?.[0];
+    if (!o) throw new Error(`Invalid metadata near "${r.slice(e)}".`);
+    if (e += o.length, i(), r[e++] !== "=") throw new Error(`Expected '=' after ${o}.`);
+    if (i(), r[e++] !== '"') throw new Error(`${o} must use a quoted value.`);
+    let c = "", d = !1;
+    for (; e < r.length; ) {
+      const s = r[e++];
+      if (s === '"') {
+        d = !0;
+        break;
+      }
+      if (s === "\\") {
+        const l = r[e++];
+        if (l !== '"' && l !== "\\") throw new Error(`Invalid escape in ${o}.`);
+        c += l;
+      } else {
+        if (w(s)) throw new Error(`${o} cannot contain control characters.`);
+        c += s;
+      }
+    }
+    if (!d) throw new Error(`Unclosed value for ${o}.`);
+    if (!["id", "alt", "caption", "src", "mode", "state"].includes(o))
+      throw new Error(`Unknown draft option "${o}".`);
+    if (Object.hasOwn(t, o)) throw new Error(`Duplicate draft option "${o}".`);
+    t[o] = c, i();
+  }
+  if (t.id !== void 0 && !/^[A-Za-z0-9_-]+$/.test(t.id))
+    throw new Error("id must be a non-empty ASCII token.");
+  if (t.mode !== void 0 && t.mode !== "static" && t.mode !== "interactive")
+    throw new Error('mode must be "static" or "interactive".');
+  if (t.src !== void 0 && (!t.src.endsWith(".draft") || t.src.trim() !== t.src || t.src.includes("\0") || t.src.startsWith("/") || t.src.startsWith("\\") || /^[A-Za-z][A-Za-z\d+.-]*:/.test(t.src) || /^[A-Za-z]:/.test(t.src)))
+    throw new Error("src must name a relative local .draft file.");
+  return t;
+}
+export {
+  f as p
+};

package/dist/client.js

@@ -0,0 +1,153 @@
+import { mountViewer as k } from "@draftably/runtime/viewer";
+const m = 1e6, v = 1e6;
+function T(e) {
+  for (const a of e) {
+    const n = a.charCodeAt(0);
+    if (n < 32 || n === 127) return !0;
+  }
+  return !1;
+}
+function p(e, a, n) {
+  if (!e || T(e)) throw new Error("Invalid initialization URL.");
+  const i = new URL(e, n);
+  if (!["http:", "https:"].includes(i.protocol) || i.origin !== a || i.username || i.password)
+    throw new Error("Initialization URL must be same-origin.");
+  return i;
+}
+function A(e, a, n) {
+  if (new TextEncoder().encode(e).byteLength > m) throw new Error("Initialization data exceeds the size limit.");
+  let o;
+  try {
+    o = JSON.parse(e);
+  } catch {
+    throw new Error("Initialization data is not valid JSON.");
+  }
+  if (!o || typeof o != "object" || Array.isArray(o))
+    throw new Error("Initialization data has an invalid shape.");
+  const t = o;
+  if (Object.keys(t).sort().join(",") !== "key,label,policyId,source,state,version")
+    throw new Error("Initialization data has unknown or missing fields.");
+  if (t.version !== 1 || t.key !== a || !/^draft-[0-9a-f]{24}$/.test(a))
+    throw new Error("Initialization identity is invalid.");
+  if (t.policyId !== n || typeof t.policyId != "string")
+    throw new Error("Initialization policy does not match.");
+  if (typeof t.source != "string" || new TextEncoder().encode(t.source).byteLength > v)
+    throw new Error("Diagram source is invalid or too large.");
+  if (typeof t.label != "string" || t.label.length > 2e3)
+    throw new Error("Diagram label is invalid.");
+  if (t.state !== null && typeof t.state != "string")
+    throw new Error("Diagram state is invalid.");
+  return t;
+}
+const u = /* @__PURE__ */ new WeakSet();
+async function S(e) {
+  if (!e.ok) throw new Error(`Initialization request failed with HTTP ${e.status}.`);
+  const a = Number(e.headers.get("content-length"));
+  if (Number.isFinite(a) && a > m)
+    throw new Error("Initialization response exceeds the size limit.");
+  if (!e.body) throw new Error("Initialization response has no body.");
+  const n = e.body.getReader(), i = [];
+  let o = 0;
+  try {
+    for (; ; ) {
+      const { done: s, value: f } = await n.read();
+      if (s) break;
+      if (o += f.byteLength, o > m)
+        throw await n.cancel(), new Error("Initialization response exceeds the size limit.");
+      i.push(f);
+    }
+  } finally {
+    n.releaseLock();
+  }
+  const t = new Uint8Array(o);
+  let l = 0;
+  for (const s of i)
+    t.set(s, l), l += s.byteLength;
+  return new TextDecoder("utf-8", { fatal: !0 }).decode(t);
+}
+function D(e) {
+  return { code: "DRAFT_ENHANCE", severity: "warning", message: e, itemIds: [] };
+}
+function U(e, a) {
+  if (u.has(e))
+    throw new Error("This Markdown root already has an active Draftably enhancement.");
+  u.add(e);
+  const n = e.ownerDocument, i = n.defaultView;
+  if (!i)
+    throw u.delete(e), new Error("The Markdown root has no browser window.");
+  let o = !1;
+  const t = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Set(), s = [], f = (r) => {
+    try {
+      a.onDiagnostic?.(D(r));
+    } catch {
+    }
+  }, I = Array.from(
+    e.querySelectorAll("[data-draftably-region][data-draftably-init]")
+  );
+  for (const r of I) {
+    const w = r.closest("figure")?.querySelector("img");
+    if (w) {
+      const h = w.hidden;
+      s.push(() => {
+        w.hidden = h;
+      });
+    }
+    const c = new i.AbortController();
+    t.add(c), (async () => {
+      let h;
+      try {
+        const y = p(
+          r.dataset.draftablyInit ?? "",
+          i.location.origin,
+          n.baseURI
+        ), g = await i.fetch(y, {
+          signal: c.signal,
+          credentials: "same-origin",
+          redirect: "error"
+        });
+        g.url && p(g.url, i.location.origin, n.baseURI);
+        const z = await S(g);
+        if (o || c.signal.aborted) return;
+        const d = A(
+          z,
+          r.dataset.draftablyKey ?? "",
+          r.dataset.draftablyPolicy ?? ""
+        ), b = a.policies.get(d.policyId);
+        if (!b) throw new Error("No viewer policy is configured for this diagram.");
+        if (r.dataset.draftablyKey !== d.key || r.dataset.draftablyPolicy !== d.policyId)
+          throw new Error("Figure markers do not match initialization data.");
+        if (r.childNodes.length) throw new Error("Viewer region is not empty.");
+        h = k(r, { ...b, label: b.label ?? d.label }), l.add(h);
+        const E = await h.update(d.source, {
+          state: d.state,
+          camera: "fit",
+          signal: c.signal
+        });
+        if (o || c.signal.aborted) return;
+        E.status === "committed" && w ? w.hidden = !0 : E.status === "error" && f("The interactive diagram could not load. The static image is still available.");
+      } catch (y) {
+        !o && !c.signal.aborted && f(
+          y instanceof Error ? y.message : "The interactive diagram could not load."
+        );
+      } finally {
+        t.delete(c);
+      }
+    })();
+  }
+  return {
+    destroy() {
+      if (!o) {
+        o = !0;
+        for (const r of t) r.abort();
+        t.clear();
+        for (const r of l) r.destroy();
+        l.clear();
+        for (const r of s) r();
+        s.length = 0, u.delete(e);
+      }
+    }
+  };
+}
+export {
+  U as enhanceDrafts
+};

package/dist/files.js

@@ -0,0 +1,103 @@
+import { randomUUID as v, createHash as $ } from "node:crypto";
+import { mkdir as m, readdir as x, readFile as p, writeFile as b, link as N, rm as U } from "node:fs/promises";
+import { resolve as h, join as l } from "node:path";
+function A(t) {
+  return $("sha256").update(t).digest("hex");
+}
+function g(t, r) {
+  return `draft-${A(t)}.${r}`;
+}
+function j(t) {
+  for (const r of t) {
+    const o = r.charCodeAt(0);
+    if (o < 32 || o === 127) return !0;
+  }
+  return !1;
+}
+function S(t) {
+  if (typeof t != "string" || !t || /[\s\\?#]/.test(t) || j(t))
+    throw new TypeError(
+      "publicPath must be a URL path without query, hash, backslash, or controls."
+    );
+  let r;
+  if (t.startsWith("/")) {
+    if (t.startsWith("//"))
+      throw new TypeError("publicPath must not be protocol-relative.");
+    r = t;
+  } else {
+    let o;
+    try {
+      o = new URL(t);
+    } catch {
+      throw new TypeError("publicPath must be root-relative or an absolute HTTP(S) URL.");
+    }
+    if (!["http:", "https:"].includes(o.protocol) || o.username || o.password)
+      throw new TypeError("publicPath must be root-relative or an absolute HTTP(S) URL.");
+    r = `${o.origin}${o.pathname}`;
+  }
+  return r.replace(/\/+$/, "");
+}
+async function d(t, r, o) {
+  await m(t, { recursive: !0 });
+  const s = l(t, r), c = l(t, `.${r}.${v()}.tmp`);
+  try {
+    await b(c, o, { flag: "wx" });
+    try {
+      await N(c, s);
+    } catch (f) {
+      if (f.code !== "EEXIST") throw f;
+      if (!(await p(s)).equals(o)) throw new Error(`Asset collision: ${r}`, { cause: f });
+    }
+  } finally {
+    await U(c, { force: !0 });
+  }
+}
+function y(t, r) {
+  const o = t.endsWith(".svg") ? "svg" : t.endsWith(".json") ? "json" : void 0;
+  return !!o && t === g(r, o);
+}
+function R(t) {
+  if (!t || typeof t.directory != "string" || !t.directory)
+    throw new TypeError("directory must be a non-empty path.");
+  const r = h(t.directory), o = S(t.publicPath), s = /* @__PURE__ */ new Map();
+  async function c(e, i) {
+    if (!y(e, i))
+      throw new TypeError(`Invalid content-addressed asset name: ${e}`);
+    let n = s.get(e);
+    n || (n = d(r, e, i), s.set(e, n));
+    try {
+      await n;
+    } finally {
+      s.get(e) === n && s.delete(e);
+    }
+  }
+  const f = (e) => `${o}/${e}`, u = async (e) => {
+    if (e.mediaType !== "image/svg+xml" || !e.fileName.endsWith(".svg"))
+      throw new TypeError("Expected a content-addressed Draftably SVG.");
+    return await c(e.fileName, e.bytes), { url: f(e.fileName) };
+  }, T = async (e) => {
+    const i = new TextEncoder().encode(JSON.stringify(e)), n = g(i, "json");
+    return await c(n, i), { fileName: n, url: f(n) };
+  };
+  async function E(e) {
+    const i = h(e);
+    await m(i, { recursive: !0 });
+    let n;
+    try {
+      n = await x(r);
+    } catch (a) {
+      if (a.code === "ENOENT") return;
+      throw a;
+    }
+    for (const a of n) {
+      if (!/^draft-[0-9a-f]{64}\.(?:svg|json)$/.test(a)) continue;
+      const w = await p(l(r, a));
+      if (!y(a, w)) throw new Error(`Asset content hash mismatch: ${a}`);
+      await d(i, a, w);
+    }
+  }
+  return { directory: r, emitAsset: u, emitInit: T, copyTo: E };
+}
+export {
+  R as createFileAssets
+};

package/dist/index.js

@@ -0,0 +1,8 @@
+import "node:crypto";
+import "@draftably/runtime";
+import "node:fs/promises";
+import "node:path";
+import { p as e } from "./chunks/metadata-Dx6T_2Zy.js";
+export {
+  e as parseFenceOptions
+};

package/dist/markdown-it.js

@@ -0,0 +1,156 @@
+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 M(t) {
+  return t.replace(
+    /[&<>"']/g,
+    (e) => ({
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    })[e]
+  );
+}
+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, 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 (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 (c === "image") {
+    const r = t.data?.hProperties ?? {};
+    return _({
+      url: String(t.url ?? ""),
+      alt: String(t.alt ?? ""),
+      ...typeof r.width == "number" ? { width: r.width } : {},
+      ...typeof r.height == "number" ? { height: r.height } : {}
+    });
+  }
+  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 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 (c === "text") return e(String(t.value ?? ""));
+  throw new Error(`Unsupported generated AST node: ${String(c)}.`);
+}
+function B(t) {
+  if (!t || typeof t.emitAsset != "function")
+    throw new TypeError("createMarkdownItDraft requires an emitAsset function.");
+  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(v.node, (k) => s.utils.escapeHtml(k));
+    };
+  }
+  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(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: (m) => {
+        p.add(m.dependencyPath);
+        try {
+          t.sources?.onDependency?.(m);
+        } catch (a) {
+          throw H(a, "Markdown dependency callback failed.");
+        }
+      }
+    };
+    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 = 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 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 S = w?.source ?? a.content ?? "", i = await F(S, n, D, l, P, {
+              ...t,
+              sources: $
+            });
+            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 (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.",
+              D
+            );
+            if (g.push(...i ?? [u]), (t.errors ?? "fail") === "fail")
+              throw Object.assign(new Error("Draftably Markdown preparation failed."), {
+                diagnostics: i ?? [u]
+              });
+            e.set(a, {
+              node: {
+                type: "paragraph",
+                children: [{ type: "text", value: "Diagram unavailable." }]
+              },
+              diagnostics: i ?? [u]
+            });
+          }
+        }
+        a.children?.length && await k(a.children);
+      }
+    };
+    await k(o);
+    for (const m of g) t.onDiagnostic?.(m);
+    return {
+      version: 1,
+      assets: d,
+      clientModules: [...y],
+      dependencies: [...p],
+      diagnostics: g
+    };
+  }
+  return { plugin: r, prepare: h, render: f };
+}
+export {
+  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-IVovOQE9.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

@@ -0,0 +1,86 @@
+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 (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 O(r, "Markdown dependency callback failed.");
+        }
+      }
+    }, o = [], y = /* @__PURE__ */ new Set();
+    let E = 0;
+    async function D(i) {
+      const r = i.children;
+      if (r)
+        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 = 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 && 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 && y.add(e.id);
+              const h = l?.source ?? t.value ?? "", a = await k(h, e, d, b, M, {
+                ...s,
+                sources: v
+              });
+              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 (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.",
+                d
+              );
+              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(c, 1, {
+                type: "paragraph",
+                children: [{ type: "text", value: "Diagram unavailable." }]
+              });
+            }
+          } else
+            await D(t);
+        }
+    }
+    await D(A);
+    for (const i of o) s.onDiagnostic?.(i);
+    f.data ??= {}, f.data.draftably = {
+      version: 1,
+      assets: m,
+      clientModules: [...w],
+      dependencies: [...p],
+      diagnostics: o
+    };
+  };
+}
+export {
+  R as default
+};

package/dist/types/packages/markdown/src/client-validation.d.ts

@@ -0,0 +1,5 @@
+import type { DraftViewerInitV1 } from './core.js';
+export declare const MAX_INIT_BYTES = 1000000;
+export declare const MAX_SOURCE_BYTES = 1000000;
+export declare function sameOriginInitUrl(value: string, origin: string, baseUrl: string): URL;
+export declare function parseInitJson(text: string, expectedKey: string, expectedPolicy: string): DraftViewerInitV1;

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

@@ -0,0 +1,12 @@
+import { mountViewer } from '@draftably/runtime/viewer';
+import type { Diagnostic } from '@draftably/runtime';
+type ViewerOptions = Parameters<typeof mountViewer>[1];
+export interface EnhanceDraftsOptions {
+    policies: ReadonlyMap<string, ViewerOptions>;
+    onDiagnostic?: (diagnostic: Diagnostic) => void;
+}
+/** Load generated init assets and progressively enhance static diagram figures under root. */
+export declare function enhanceDrafts(root: HTMLElement, options: EnhanceDraftsOptions): {
+    destroy(): void;
+};
+export {};