@draftably/markdown 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,25 @@
-# Temporary Holding Version
+# `@draftably/markdown`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Turn `draft` code fences, and optionally `mermaid` fences, into static SVG images when your site
+builds. It has a remark plugin (Unified, MDX, Astro, Docusaurus) and a markdown-it plugin. Readers
+load no Draftably JavaScript.
+
+```sh
+pnpm add @draftably/markdown
+```
+
+```ts
+import remarkDraft from '@draftably/markdown/remark';
+import { createFileAssets } from '@draftably/markdown/files';
+
+const assets = createFileAssets({ directory: '.cache/diagrams', publicPath: '/diagrams/' });
+processor.use(remarkDraft, { emitAsset: assets.emitAsset });
+// After the build: await assets.copyTo('dist/diagrams');
+```
+
+## Docs
+
+- [Markdown](https://draftably.dev/docs/markdown): a first build, fence options, includes,
+  Mermaid fences and interactive mode
+- [Documentation sites](https://draftably.dev/docs/documentation-sites): Astro Starlight,
+  Docusaurus and VitePress recipes

package/dist/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Byron Wall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunks/core-D4HpamVq.js

@@ -0,0 +1,323 @@
+import { createHash as J } from "node:crypto";
+import { runtimeVersion as W, fontMetricsVersion as Z, renderSvg as H } from "@draftably/runtime";
+import { realpath as D, stat as K, readFile as V } from "node:fs/promises";
+import { resolve as k, relative as q, sep as G, isAbsolute as Y } from "node:path";
+function N(e, t) {
+  const r = q(e, t);
+  return r === "" || r !== ".." && !r.startsWith(`..${G}`) && !Y(r);
+}
+async function Q(e, t, r) {
+  if (!e || e.includes("\0") || e.startsWith("/") || e.startsWith("\\") || /^[A-Za-z][A-Za-z\d+.-]*:/.test(e) || /^[A-Za-z]:/.test(e))
+    throw new Error("src must be a relative local path.");
+  const s = await D(r), g = k(t, "..", e);
+  if (!N(k(r), g))
+    throw new Error("src is outside the configured content root.");
+  let n;
+  try {
+    n = await D(g);
+  } catch (m) {
+    let f = g, y;
+    for (; f !== k(f, ".."); )
+      try {
+        const l = await D(f);
+        if (!N(s, l))
+          throw new Error("src resolves outside the configured content root.", { cause: m });
+        y = l;
+        break;
+      } catch (l) {
+        if (l instanceof Error && l.message.includes("outside"))
+          throw l;
+        f = k(f, "..");
+      }
+    throw Object.assign(new Error("Included .draft file does not exist.", { cause: m }), {
+      missingPath: g,
+      watchPath: y
+    });
+  }
+  if (!N(s, n))
+    throw new Error("src resolves outside the configured content root.");
+  if (!n.endsWith(".draft")) throw new Error("src must name a .draft file.");
+  const p = await K(n);
+  if (!p.isFile()) throw new Error("src must name a regular file.");
+  if (p.size > 1e6) throw new Error("Included .draft file exceeds 1 MB.");
+  const h = await V(n);
+  if (h.byteLength > 1e6) throw new Error("Included .draft file exceeds 1 MB.");
+  return { source: new TextDecoder("utf-8", { fatal: !0 }).decode(h), path: n };
+}
+async function se(e, t, r) {
+  if (r.mermaid !== "convert") return { source: null, diagnostics: [] };
+  const { convertMermaid: s } = await import("../mermaid.js");
+  return s(e, t);
+}
+function z(e, t, r, s) {
+  return {
+    code: e,
+    severity: "error",
+    message: t,
+    location: r,
+    itemIds: [],
+    ...s ? { related: s } : {}
+  };
+}
+function M(e) {
+  return J("sha256").update(e).digest("hex");
+}
+function x(e) {
+  for (const t of e) {
+    const r = t.charCodeAt(0);
+    if (r < 32 || r === 127) return !0;
+  }
+  return !1;
+}
+function c(e, t = "Markdown host operation failed.") {
+  return X(e) ? e : Object.assign(new Error(t, { cause: e }), { hostFailure: !0 });
+}
+function X(e) {
+  return !!e && typeof e == "object" && "hostFailure" in e;
+}
+function P(e, t, r) {
+  return Object.assign(new Error(t), { diagnostic: z(e, t, r) });
+}
+function ce(e) {
+  return !!e && typeof e == "object" && "noPlaceholder" in e;
+}
+function F(e) {
+  if (e?.aborted)
+    throw Object.assign(new Error("Markdown diagram preparation was aborted."), {
+      noPlaceholder: !0,
+      cause: e.reason
+    });
+}
+const v = /* @__PURE__ */ new Map(), ee = 128;
+function te(e, t) {
+  const r = e.render ?? {};
+  if (!(r.links?.mode === "safe" && r.links.resolve && !r.links.cacheKey))
+    return JSON.stringify({
+      includeSource: r.includeSource ?? !1,
+      links: r.links ?? { mode: "none" },
+      limits: r.limits ?? {},
+      state: t ?? null,
+      target: "image",
+      fonts: "embed"
+    });
+}
+async function le(e, t, r, s, g, n) {
+  const p = [];
+  F(n.render?.signal);
+  let h = e, m = s.path, f, y = !1;
+  if (t.src) {
+    if (e.trim())
+      throw P(
+        "DRAFT_INCLUDE",
+        "src cannot be combined with a non-empty fence body.",
+        r
+      );
+    if (!s.path || !n.sources)
+      throw P(
+        "DRAFT_INCLUDE",
+        "src requires a document path and configured sources.rootDir.",
+        r
+      );
+    let i;
+    try {
+      i = await Q(t.src, s.path, n.sources.rootDir);
+    } catch (a) {
+      const { missingPath: u, watchPath: I } = a;
+      if (u)
+        try {
+          n.sources.onDependency?.({
+            documentPath: s.path,
+            dependencyPath: u,
+            missing: !0,
+            watchPath: I
+          });
+        } catch (A) {
+          throw c(A, "Markdown dependency callback failed.");
+        }
+      const o = a instanceof Error ? a.message : "Could not read included diagram.";
+      throw Object.assign(new Error(o), {
+        diagnostic: z(
+          "DRAFT_INCLUDE",
+          o,
+          r,
+          u ? [{ message: "Included here.", location: r }] : void 0
+        )
+      });
+    }
+    h = i.source, m = i.path, y = !0, f = i.path;
+    try {
+      n.sources.onDependency?.({
+        documentPath: s.path,
+        dependencyPath: i.path,
+        missing: !1
+      });
+    } catch (a) {
+      throw c(a, "Markdown dependency callback failed.");
+    }
+  }
+  if (t.mode === "interactive" && !n.interactive) {
+    const i = P(
+      "DRAFT_CAPABILITY",
+      "Interactive diagrams require a configured enhancement bridge.",
+      r
+    );
+    throw Object.assign(i, { noPlaceholder: !0 }), i;
+  }
+  const l = te(n, t.state), b = l === void 0 ? void 0 : M(
+    JSON.stringify([
+      h,
+      m ?? "",
+      W,
+      Z,
+      l
+    ])
+  );
+  let w = b ? v.get(b) : void 0;
+  const L = (i) => i.map((a) => ({
+    ...a,
+    location: a.location ? {
+      ...a.location,
+      line: a.location.line + (y ? 0 : r?.line ?? 1),
+      ...y ? {} : { column: void 0 }
+    } : r,
+    ...y && r ? { related: [...a.related ?? [], { message: "Included here.", location: r }] } : {}
+  }));
+  if (!w) {
+    let i;
+    try {
+      i = await H(h, {
+        ...n.render ?? {},
+        target: "image",
+        fonts: "embed",
+        includeSource: n.render?.includeSource ?? !1,
+        links: n.render?.links ?? { mode: "none" },
+        sourceId: m,
+        state: t.state ?? null
+      });
+    } catch (a) {
+      throw Object.assign(new Error("Draftably renderer failed."), {
+        noPlaceholder: !0,
+        cause: a
+      });
+    }
+    if (!i.ok) {
+      const a = L(i.diagnostics);
+      p.push(...a);
+      const u = Object.assign(new Error("Draftably could not render this diagram."), {
+        diagnostics: a
+      });
+      if ((n.errors ?? "fail") === "fail" || !["input", "limit"].includes(i.reason))
+        throw Object.assign(u, { noPlaceholder: !0 }), u;
+      return {
+        node: { type: "paragraph", children: [{ type: "text", value: "Diagram unavailable." }] },
+        diagnostics: p
+      };
+    }
+    w = {
+      svg: i.value.svg,
+      width: i.value.width,
+      height: i.value.height,
+      title: i.value.title,
+      diagnostics: i.diagnostics
+    }, b && (v.set(b, w), v.size > ee && v.delete(v.keys().next().value));
+  }
+  p.push(...L(w.diagnostics)), F(n.render?.signal);
+  const S = new TextEncoder().encode(w.svg), T = `draft-${M(S)}.svg`;
+  let d;
+  try {
+    d = await n.emitAsset(
+      { fileName: T, mediaType: "image/svg+xml", bytes: S },
+      { document: s, fenceIndex: g }
+    );
+  } catch (i) {
+    throw c(i, "SVG asset emitter failed.");
+  }
+  if (!d || typeof d.url != "string")
+    throw c(new TypeError("Asset emitter must return a URL string."));
+  let O;
+  try {
+    O = new URL(d.url, "https://draftably.invalid");
+  } catch {
+    throw c(new Error("Asset emitter returned an invalid URL."));
+  }
+  if (!d.url || d.url.charCodeAt(0) <= 32 || x(d.url) || !["https:", "http:"].includes(O.protocol))
+    throw c(new Error("Asset emitter returned an unsafe URL."));
+  const U = t.alt?.trim() || w.title, _ = {
+    type: "image",
+    url: d.url,
+    alt: U,
+    data: { hProperties: { width: Math.ceil(w.width), height: Math.ceil(w.height) } }
+  }, B = { fileName: T, url: d.url }, R = [];
+  let j;
+  const E = [_];
+  if (t.mode === "interactive") {
+    const i = n.interactive;
+    if (!/^[A-Za-z0-9._-]{1,64}$/.test(i.policyId))
+      throw c(new TypeError("Interactive policyId must be a short ASCII token."));
+    const a = `draft-${M(JSON.stringify([h, t.state ?? null, t.id ?? null, g])).slice(0, 24)}`, u = {
+      version: 1,
+      key: a,
+      source: h,
+      state: t.state ?? null,
+      label: U,
+      policyId: i.policyId
+    }, I = new TextEncoder().encode(JSON.stringify(u));
+    if (I.byteLength > 1e6)
+      throw P("DRAFT_LIMIT", "Interactive initialization data exceeds 1 MB.", r);
+    let o;
+    try {
+      o = await i.emitInit(u);
+    } catch ($) {
+      throw c($, "Interactive initialization emitter failed.");
+    }
+    if (!o || typeof o.fileName != "string" || typeof o.url != "string")
+      throw c(new TypeError("Initialization emitter must return a filename and URL."));
+    let A, C;
+    try {
+      A = new URL(o.url, "https://draftably.invalid"), C = new URL(i.clientModuleUrl, "https://draftably.invalid");
+    } catch {
+      throw c(new Error("Interactive bridge returned an invalid URL."));
+    }
+    if (o.fileName !== `draft-${M(I)}.json` || !o.url || o.url.charCodeAt(0) <= 32 || x(o.url) || !["https:", "http:"].includes(A.protocol))
+      throw c(new Error("Initialization emitter returned an invalid asset."));
+    if (!i.clientModuleUrl || i.clientModuleUrl.charCodeAt(0) <= 32 || x(i.clientModuleUrl) || !["https:", "http:"].includes(C.protocol))
+      throw c(new Error("clientModuleUrl is unsafe."));
+    R.push({ fileName: o.fileName, url: o.url }), j = i.clientModuleUrl, E.push({
+      type: "div",
+      data: {
+        hName: "div",
+        hProperties: {
+          className: ["draftably-viewer-region"],
+          "data-draftably-region": "",
+          "data-draftably-init": o.url,
+          "data-draftably-policy": i.policyId,
+          "data-draftably-key": a,
+          role: "region",
+          "aria-label": U
+        }
+      },
+      children: []
+    });
+  }
+  return t.caption && E.push({
+    type: "figcaption",
+    data: { hName: "figcaption" },
+    children: [{ type: "text", value: t.caption }]
+  }), { node: t.mode === "interactive" || t.caption ? {
+    type: "figure",
+    data: { hName: "figure", ...t.id ? { hProperties: { id: t.id } } : {} },
+    children: E
+  } : {
+    type: "paragraph",
+    ...t.id ? { data: { hProperties: { id: t.id } } } : {},
+    children: E
+  }, asset: B, extraAssets: R, clientModule: j, diagnostics: p, dependency: f };
+}
+export {
+  z as a,
+  ce as b,
+  c as h,
+  X as i,
+  se as m,
+  le as p
+};

package/dist/chunks/mermaid-facade-BoLWBerE.js

@@ -0,0 +1,289 @@
+const E = "12.2.0";
+const l = (t) => {
+  if (!t || typeof t != "object" || Array.isArray(t))
+    throw new Error("Expected a Mermaid data object.");
+  return t;
+}, a = (t, s) => {
+  if (typeof t == "string") return t;
+  if (t == null && s !== void 0) return s;
+  throw new Error("Expected a Mermaid string.");
+}, m = (t) => {
+  if (t == null) return [];
+  if (!Array.isArray(t) || t.some((s) => typeof s != "string"))
+    throw new Error("Expected a Mermaid string array.");
+  return [...t];
+}, i = (t) => t == null ? void 0 : a(t), y = (t) => {
+  if (!Array.isArray(t)) throw new Error("Expected a Mermaid array.");
+  return t;
+}, x = (t) => {
+  if (!(t instanceof Map)) throw new Error("Expected a Mermaid Map.");
+  return [...t.values()];
+}, b = (t) => {
+  if (t != null) {
+    if (typeof t != "number" || !Number.isFinite(t))
+      throw new Error("Expected finite number.");
+    return t;
+  }
+};
+function w(t) {
+  return t.replace(/fl°°(\d+)¶ß/g, "&#$1;").replace(/fl°([A-Za-z]\w*)¶ß/g, "&$1;");
+}
+function P(t) {
+  return (s) => {
+    const g = t.createElement("template");
+    return g.innerHTML = w(s).replace(/<br\s*\/?>/gi, `
+`), g.content.textContent ?? "";
+  };
+}
+function R(t) {
+  if (new TextEncoder().encode(t).length > 1e5)
+    return [
+      {
+        code: "IMPORT_INPUT_LIMIT",
+        severity: "error",
+        message: "Mermaid input exceeds 100000 UTF-8 bytes."
+      }
+    ];
+  const s = t.replace(/^\uFEFF/, "").replace(/\r\n?/g, `
+`);
+  if (/^\s*---(?:\n|$)/.test(s) || /%%\s*\{/.test(s))
+    return [
+      {
+        code: "MERMAID_CONFIGURATION_UNSUPPORTED",
+        severity: "error",
+        message: "This importer does not apply Mermaid frontmatter or directives. Remove the configuration block and import the diagram text."
+      }
+    ];
+  if ([...s].some((o) => {
+    const d = o.charCodeAt(0);
+    return d < 32 && ![9, 10, 13].includes(d);
+  }))
+    return [
+      {
+        code: "IMPORT_CONTROL_CHARACTER",
+        severity: "error",
+        message: "Input contains unsupported control characters."
+      }
+    ];
+  const g = s.split(`
+`).find((o) => o.trim() && !o.trimStart().startsWith("%%")) ?? "";
+  if (!/^\s*(?:flowchart|graph|sequenceDiagram)\b/.test(g))
+    return [
+      {
+        code: "MERMAID_FAMILY_UNSUPPORTED",
+        severity: "error",
+        message: "This adapter supports Mermaid flowcharts and sequence diagrams only. Class, ER, state, chart and other families require separate semantic adapters."
+      }
+    ];
+  const f = [];
+  for (const [o, d] of s.split(`
+`).entries())
+    /(?:^|;)\s*click\s/.test(d) && f.push({
+      code: "MERMAID_INTERACTION_IGNORED",
+      severity: "warning",
+      message: "Mermaid click links and callbacks are data only; no interactions are installed.",
+      line: o + 1,
+      locationKind: "source"
+    });
+  return f;
+}
+function S(t, s) {
+  const g = new Map(
+    Object.entries(l(t.LINETYPE)).map(([n, r]) => [r, n])
+  ), f = new Map(
+    Object.entries(l(t.PLACEMENT)).map(([n, r]) => [r, n])
+  ), o = y(s("getBoxes")), d = s("getActors");
+  if (!(d instanceof Map)) throw new Error("Expected a Mermaid Map.");
+  const p = (n) => new Set(s(n) instanceof Map ? s(n).keys() : []);
+  return {
+    format: "mermaid",
+    family: "sequence",
+    parserVersion: E,
+    title: i(s("getDiagramTitle")) || void 0,
+    actors: m(s("getActorKeys")).map((n) => {
+      const r = l(d.get(n));
+      return {
+        id: n,
+        name: a(r.description, a(r.name, n)),
+        type: a(r.type, "participant"),
+        box: r.box ? o.indexOf(r.box) : void 0,
+        links: Object.keys(l(r.links ?? {}))
+      };
+    }),
+    boxes: o.map((n) => {
+      const r = l(n);
+      return { name: i(r.name), fill: i(r.fill) };
+    }),
+    events: y(s("getMessages")).map((n) => {
+      const r = l(n), u = f.get(r.placement);
+      return {
+        kind: g.get(r.type) ?? "UNKNOWN",
+        from: i(r.from),
+        to: i(r.to),
+        // `autonumber` stores its numbering object here.
+        text: typeof r.message == "string" ? r.message : "",
+        ...r.placement == null ? {} : {
+          placement: u === "LEFTOF" ? "left" : u === "RIGHTOF" ? "right" : "over"
+        },
+        central: !!r.centralConnection
+      };
+    }),
+    created: [...p("getCreatedActors")].map(String),
+    destroyed: [...p("getDestroyedActors")].map(String)
+  };
+}
+function D(t) {
+  let s = Promise.resolve();
+  return (g) => {
+    const f = s.then(async () => {
+      const o = R(g);
+      if (o.some((p) => p.severity === "error")) return { ok: !1, diagnostics: o };
+      let d = "load";
+      try {
+        const p = await t();
+        p.initialize({
+          startOnLoad: !1,
+          securityLevel: "strict",
+          htmlLabels: !1,
+          maxTextSize: 1e5,
+          maxEdges: 3e3,
+          suppressErrorRendering: !0
+        }), d = "parse";
+        const n = await p.mermaidAPI.getDiagramFromText(g.replace(/^\uFEFF/, ""));
+        if (!["flowchart", "flowchart-v2", "sequence"].includes(n.type))
+          return {
+            ok: !1,
+            diagnostics: [
+              ...o,
+              {
+                code: "MERMAID_FAMILY_UNSUPPORTED",
+                severity: "error",
+                message: `Parser selected unsupported diagram family ${n.type}.`
+              }
+            ]
+          };
+        d = "snapshot";
+        const r = l(n.db), u = (c) => {
+          if (typeof r[c] != "function")
+            throw new Error(`Mermaid ${E} boundary missing ${c}().`);
+          return r[c].call(r);
+        };
+        if (n.type === "sequence") {
+          const c = S(r, u);
+          return c.actors.length > 1e3 || c.events.length > 3e3 ? {
+            ok: !1,
+            diagnostics: [
+              ...o,
+              {
+                code: "IMPORT_GRAPH_LIMIT",
+                severity: "error",
+                message: "Parsed sequence exceeds the import entity or event limit."
+              }
+            ]
+          } : { ok: !0, diagnostics: o, snapshot: c };
+        }
+        const M = u("getEdges"), h = x(u("getVertices")).map((c) => {
+          const e = l(c);
+          return {
+            id: a(e.id),
+            text: a(e.text, a(e.id)),
+            type: i(e.type),
+            labelType: a(e.labelType, "text"),
+            classes: m(e.classes),
+            styles: m(e.styles),
+            link: i(e.link),
+            icon: i(e.icon),
+            img: i(e.img),
+            props: e.props == null ? void 0 : structuredClone(l(e.props))
+          };
+        }), T = y(M).map((c) => {
+          const e = l(c);
+          return {
+            start: a(e.start),
+            end: a(e.end),
+            text: a(e.text, ""),
+            type: i(e.type),
+            stroke: i(e.stroke),
+            id: i(e.id),
+            isUserDefinedId: e.isUserDefinedId === !0,
+            labelType: a(e.labelType, "text"),
+            classes: m(e.classes),
+            style: m(e.style),
+            length: b(e.length),
+            interpolate: i(e.interpolate),
+            animate: e.animate === !0,
+            animation: i(e.animation)
+          };
+        }), A = y(u("getSubGraphs")).map((c) => {
+          const e = l(c);
+          return {
+            id: a(e.id),
+            title: a(e.title, ""),
+            nodes: m(e.nodes),
+            dir: i(e.dir),
+            labelType: a(e.labelType, "text"),
+            classes: m(e.classes),
+            metadata: e.metadata == null ? void 0 : structuredClone(l(e.metadata))
+          };
+        }), _ = x(u("getClasses")).map((c) => {
+          const e = l(c);
+          return { id: a(e.id), styles: m(e.styles), textStyles: m(e.textStyles) };
+        });
+        if (h.length + A.length > 1e3 || T.length > 3e3)
+          return {
+            ok: !1,
+            diagnostics: [
+              ...o,
+              {
+                code: "IMPORT_GRAPH_LIMIT",
+                severity: "error",
+                message: "Parsed graph exceeds the import entity or edge limit."
+              }
+            ]
+          };
+        const I = M;
+        return {
+          ok: !0,
+          diagnostics: o,
+          snapshot: {
+            format: "mermaid",
+            family: "flowchart",
+            parserVersion: E,
+            direction: a(u("getDirection"), "TB"),
+            vertices: h,
+            edges: T,
+            groups: A,
+            classes: _,
+            defaultEdgeStyle: m(I.defaultStyle),
+            defaultEdgeInterpolate: i(I.defaultInterpolate)
+          }
+        };
+      } catch (p) {
+        const n = p, r = n.hash?.loc;
+        return {
+          ok: !1,
+          diagnostics: [
+            ...o,
+            {
+              code: d === "parse" ? "MERMAID_PARSE_ERROR" : "MERMAID_ADAPTER_MISMATCH",
+              severity: "error",
+              message: n.message ?? String(p),
+              line: r?.first_line,
+              column: r?.first_column == null ? void 0 : r.first_column + 1,
+              locationKind: r ? "parser-relative" : void 0
+            }
+          ]
+        };
+      }
+    });
+    return s = f.catch(() => {
+    }), f;
+  };
+}
+export {
+  E as MERMAID_VERSION,
+  D as createMermaidFlowParser,
+  P as makePlainLabel,
+  R as preflightMermaidFlow,
+  w as restoreEntitySpelling
+};