@50arms/ui 0.0.0-stage → 35.1.0

package/dist/lib/syntax/markdown/refs.js

@@ -0,0 +1,94 @@
+import { jsx as b, Fragment as M } from "react/jsx-runtime";
+import { useMemo as p, useContext as A, useSyncExternalStore as F, useState as P, useRef as g, useEffect as x, createContext as C, Fragment as y } from "react";
+import { subscribeToTenant as L, getRecordStoreTenant as v } from "../../records/store.js";
+const S = C(null), X = C(null);
+function $({ pattern: t, resolve: e, renderRef: n, children: r }) {
+  if (!t.global)
+    throw new Error("MarkdownRefProvider: `pattern` needs the global flag (g), e.g. /\\bDX-\\d+\\b/g");
+  const o = p(() => ({ pattern: t, resolve: e, renderRef: n }), [t, e, n]);
+  return /* @__PURE__ */ b(S.Provider, { value: o, children: r });
+}
+function T(t, e) {
+  const n = [];
+  for (const r of t.matchAll(new RegExp(e.source, e.flags)))
+    r[0] !== "" && n.push({ ref: r[0], index: r.index });
+  return n;
+}
+function u(t, e) {
+  for (const n of t)
+    n.kind === "text" ? e(n.value) : (n.kind === "emphasis" || n.kind === "strong" || n.kind === "strike") && u(n.children, e);
+}
+function d(t, e) {
+  for (const n of t)
+    switch (n.kind) {
+      case "paragraph":
+      case "heading":
+        u(n.children, e);
+        break;
+      case "quote":
+        d(n.children, e);
+        break;
+      case "list":
+        for (const r of n.items) d(r.children, e);
+        break;
+      case "table":
+        for (const r of n.head) u(r.children, e);
+        for (const r of n.rows) for (const o of r) u(o.children, e);
+        break;
+      case "footnotes":
+        for (const r of n.items) d(r.children, e);
+        break;
+    }
+}
+function N(t, e) {
+  const n = /* @__PURE__ */ new Set(), r = (o) => {
+    for (const { ref: s } of T(o, e)) n.add(s);
+  };
+  return typeof t == "string" ? r(t) : d(t, r), [...n];
+}
+const m = /* @__PURE__ */ new Map();
+function j(t) {
+  const e = A(S), n = e?.pattern, r = p(() => n ? N(t, n) : [], [t, n]), o = F(L, v, v), [s, E] = P({ tenant: o, map: m }), w = s.tenant === o ? s.map : m, f = g(/* @__PURE__ */ new Set()), h = g(null), R = g(e?.resolve);
+  return R.current = e?.resolve, x(() => (h.current = new AbortController(), () => {
+    h.current?.abort(), f.current.clear();
+  }), [o]), x(() => {
+    const k = R.current, a = h.current?.signal, i = r.filter((c) => !f.current.has(c));
+    if (!(!k || !a || i.length === 0)) {
+      for (const c of i) f.current.add(c);
+      k(i, a).then(
+        (c) => {
+          a.aborted || E((l) => ({ tenant: o, map: new Map([...l.tenant === o ? l.map : m, ...c]) }));
+        },
+        (c) => {
+          if (!a.aborted) {
+            for (const l of i) f.current.delete(l);
+            throw c;
+          }
+        }
+      );
+    }
+  }, [r, o]), p(
+    () => e ? { pattern: e.pattern, resolved: w, renderRef: e.renderRef } : null,
+    [e, w]
+  );
+}
+function q(t, e) {
+  if (!e || e.resolved.size === 0) return t;
+  const n = [];
+  let r = 0;
+  for (const { ref: o, index: s } of T(t, e.pattern))
+    e.resolved.has(o) && (s > r && n.push(t.slice(r, s)), n.push(/* @__PURE__ */ b(y, { children: e.renderRef(o, e.resolved.get(o)) }, s)), r = s + o.length);
+  return n.length === 0 ? t : (r < t.length && n.push(t.slice(r)), n);
+}
+function B({ children: t }) {
+  const e = j(t);
+  return /* @__PURE__ */ b(M, { children: q(t, e) });
+}
+export {
+  $ as MarkdownRefProvider,
+  X as RefLinksContext,
+  B as RefText,
+  q as linkRefs,
+  j as useRefLinks
+};
+//# sourceMappingURL=refs.js.map

package/dist/lib/syntax/markdown/refs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.js","sources":["../../../../src/lib/syntax/markdown/refs.tsx"],"sourcesContent":["import { createContext, Fragment, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore, type ReactNode } from \"react\";\nimport { getRecordStoreTenant, subscribeToTenant } from \"../../records\";\nimport type { MdInline, MdNode } from \"./types\";\n\n/* ============================================================================\n   RESOURCE REFS (DXUI-32) — `DX-6144`, `PLAN-46`, `PBLM-2757` as links.\n\n   An app mounts ONE `MarkdownRefProvider` and says three things the library\n   cannot know: which text runs ARE refs (`pattern`), how to turn a batch of\n   them into the ones that really exist (`resolve`), and how a real one draws\n   (`renderRef`, normally the app's router link — a plain `<a href>` would\n   reload the page). Which kinds of ref exist, and where each goes, is the\n   app's business and never appears in this file.\n\n   WHAT THE LIBRARY OWNS is where a ref may become a link, and that anything\n   short of a resolved ref is exactly the text it was. A ref is only ever found\n   in a `text` inline: code spans and fenced blocks are other node kinds, and a\n   link's label is skipped (an anchor inside an anchor is invalid HTML, and the\n   author already chose where that text goes). A ref that is pending, unknown\n   or whose batch failed stays plain text, so a link never flickers in and out.\n\n   Resolution is per rendered document: `MarkdownNodes` (and `RefText` for a\n   plain string) collects the distinct refs it holds, asks `resolve` once for\n   the ones it has not asked about yet, and merges the answers in. Caching\n   ACROSS documents is the app's — its `resolve` answers a ref it already knows\n   without a request. With no provider none of this runs.\n   ========================================================================= */\n\n/**\n * Pass stable references: a module-level `pattern` and a memoised (or module-level) `resolve` and\n * `renderRef`. The provider's context value memoises on all three, so an inline arrow or a regex\n * literal written in render makes every document beneath it re-collect its refs on each render.\n */\nexport interface MarkdownRefProviderProps<T> {\n  /**\n   * Matches ONE ref per match; the whole match is the ref. It must carry the\n   * `g` flag and should anchor its edges (`\\b`) so `ADX-1` is not a `DX-1`.\n   */\n  pattern: RegExp;\n  /**\n   * Resolves a batch of distinct refs to the ones that exist. A ref missing\n   * from the answer renders as text. It should honour `signal`, which aborts\n   * when the text that asked unmounts. A rejection is not swallowed.\n   */\n  resolve: (refs: string[], signal: AbortSignal) => Promise<ReadonlyMap<string, T>>;\n  /** Draws one resolved ref — the app's router link. */\n  renderRef: (ref: string, resolved: T) => ReactNode;\n  children?: ReactNode;\n}\n\ntype RefConfig = Omit<MarkdownRefProviderProps<unknown>, \"children\">;\n\n/** What a document that holds refs draws them with. */\nexport interface RefLinks {\n  pattern: RegExp;\n  resolved: ReadonlyMap<string, unknown>;\n  renderRef: (ref: string, resolved: unknown) => ReactNode;\n}\n\nconst RefConfigContext = createContext<RefConfig | null>(null);\n/** Provided by a rendered document to its inlines: the resolved refs, or none. */\nexport const RefLinksContext = createContext<RefLinks | null>(null);\n\n/** Makes ref linking available to every `Markdown`, `MarkdownNodes` and `RefText` beneath it. */\nexport function MarkdownRefProvider<T>({ pattern, resolve, renderRef, children }: MarkdownRefProviderProps<T>) {\n  if (!pattern.global) {\n    throw new Error(\"MarkdownRefProvider: `pattern` needs the global flag (g), e.g. /\\\\bDX-\\\\d+\\\\b/g\");\n  }\n  const value = useMemo(() => ({ pattern, resolve, renderRef }) as RefConfig, [pattern, resolve, renderRef]);\n  return <RefConfigContext.Provider value={value}>{children}</RefConfigContext.Provider>;\n}\n\n/* --- Finding refs --------------------------------------------------------- */\n\n/** Every ref in `text`, in order, with its position. */\nfunction matchRefs(text: string, pattern: RegExp): Array<{ ref: string; index: number }> {\n  /* `matchAll` starts at the source regex's `lastIndex`, which the app's own `.test()` or `.exec()` on this same\n     global pattern can leave non-zero; a fresh copy always starts at 0. */\n  const found: Array<{ ref: string; index: number }> = [];\n  for (const m of text.matchAll(new RegExp(pattern.source, pattern.flags))) {\n    if (m[0] !== \"\") found.push({ ref: m[0], index: m.index });\n  }\n  return found;\n}\n\nfunction inlineTexts(nodes: readonly MdInline[], visit: (text: string) => void): void {\n  for (const node of nodes) {\n    if (node.kind === \"text\") visit(node.value);\n    else if (node.kind === \"emphasis\" || node.kind === \"strong\" || node.kind === \"strike\") inlineTexts(node.children, visit);\n    /* `link` is skipped on purpose; `code`, `image`, `footnoteRef` and `break` hold no prose. */\n  }\n}\n\nfunction blockTexts(nodes: readonly MdNode[], visit: (text: string) => void): void {\n  for (const node of nodes) {\n    switch (node.kind) {\n      case \"paragraph\":\n      case \"heading\":\n        inlineTexts(node.children, visit);\n        break;\n      case \"quote\":\n        blockTexts(node.children, visit);\n        break;\n      case \"list\":\n        for (const item of node.items) blockTexts(item.children, visit);\n        break;\n      case \"table\":\n        for (const cell of node.head) inlineTexts(cell.children, visit);\n        for (const row of node.rows) for (const cell of row) inlineTexts(cell.children, visit);\n        break;\n      case \"footnotes\":\n        for (const item of node.items) blockTexts(item.children, visit);\n        break;\n      case \"code\":\n      case \"rule\":\n      case \"frontmatter\":\n        break;\n    }\n  }\n}\n\nfunction distinctRefs(source: string | readonly MdNode[], pattern: RegExp): string[] {\n  const refs = new Set<string>();\n  const visit = (text: string) => {\n    for (const { ref } of matchRefs(text, pattern)) refs.add(ref);\n  };\n  if (typeof source === \"string\") visit(source);\n  else blockTexts(source, visit);\n  return [...refs];\n}\n\n/* --- Resolving them ------------------------------------------------------- */\n\nconst NONE: ReadonlyMap<string, unknown> = new Map();\n\n/**\n * The refs of one document, resolved. `null` with no provider above, which is\n * how \"no provider: nothing changes\" holds.\n */\nexport function useRefLinks(source: string | readonly MdNode[]): RefLinks | null {\n  const config = useContext(RefConfigContext);\n  const pattern = config?.pattern;\n  const candidates = useMemo(() => (pattern ? distinctRefs(source, pattern) : []), [source, pattern]);\n  /* DXUI-84: the answers are the tenant's. They are kept with the tenant they were asked under, so a team switch\n     shows none of the old team's links at once, and the effects below re-ask under the new one. */\n  const tenant = useSyncExternalStore(subscribeToTenant, getRecordStoreTenant, getRecordStoreTenant);\n  const [answers, setAnswers] = useState<{ tenant: unknown; map: ReadonlyMap<string, unknown> }>({ tenant, map: NONE });\n  const resolved = answers.tenant === tenant ? answers.map : NONE;\n  const asked = useRef(new Set<string>());\n  const abort = useRef<AbortController | null>(null);\n  const resolveRef = useRef(config?.resolve);\n  resolveRef.current = config?.resolve;\n\n  /* One controller per tenant, for the document's lifetime in it. Created in the effect (not\n     lazily in render) and `asked` cleared on teardown, so a StrictMode\n     mount-unmount-mount re-asks what the aborted first mount never delivered, and a tenant switch\n     aborts the old team's questions. */\n  useEffect(() => {\n    abort.current = new AbortController();\n    return () => {\n      abort.current?.abort();\n      asked.current.clear();\n    };\n  }, [tenant]);\n\n  useEffect(() => {\n    const resolve = resolveRef.current;\n    const signal = abort.current?.signal;\n    const fresh = candidates.filter((ref) => !asked.current.has(ref));\n    if (!resolve || !signal || fresh.length === 0) return;\n    for (const ref of fresh) asked.current.add(ref);\n    resolve(fresh, signal).then(\n      (found) => {\n        if (!signal.aborted) {\n          setAnswers((prev) => ({ tenant, map: new Map([...(prev.tenant === tenant ? prev.map : NONE), ...found]) }));\n        }\n      },\n      (error: unknown) => {\n        if (signal.aborted) return;\n        /* Ask again next time the text changes, and let the failure surface. */\n        for (const ref of fresh) asked.current.delete(ref);\n        throw error;\n      },\n    );\n  }, [candidates, tenant]);\n\n  return useMemo(\n    () => (config ? { pattern: config.pattern, resolved, renderRef: config.renderRef } : null),\n    [config, resolved],\n  );\n}\n\n/* --- Drawing them --------------------------------------------------------- */\n\n/** `text` with each resolved ref drawn by the app; the text itself when there is nothing to draw. */\nexport function linkRefs(text: string, links: RefLinks | null): ReactNode {\n  if (!links || links.resolved.size === 0) return text;\n  const out: ReactNode[] = [];\n  let at = 0;\n  for (const { ref, index } of matchRefs(text, links.pattern)) {\n    if (!links.resolved.has(ref)) continue;\n    if (index > at) out.push(text.slice(at, index));\n    out.push(<Fragment key={index}>{links.renderRef(ref, links.resolved.get(ref))}</Fragment>);\n    at = index + ref.length;\n  }\n  if (out.length === 0) return text;\n  if (at < text.length) out.push(text.slice(at));\n  return out;\n}\n\n/**\n * Plain (non-markdown) card text with its refs linked: a one-line statement, a\n * for/against note. With no provider it is the string.\n */\nexport function RefText({ children }: { children: string }) {\n  const links = useRefLinks(children);\n  return <>{linkRefs(children, links)}</>;\n}\n"],"names":["RefConfigContext","createContext","RefLinksContext","MarkdownRefProvider","pattern","resolve","renderRef","children","value","useMemo","jsx","matchRefs","text","found","m","inlineTexts","nodes","visit","node","blockTexts","item","cell","row","distinctRefs","source","refs","ref","NONE","useRefLinks","config","useContext","candidates","tenant","useSyncExternalStore","subscribeToTenant","getRecordStoreTenant","answers","setAnswers","useState","resolved","asked","useRef","abort","resolveRef","useEffect","signal","fresh","prev","error","linkRefs","links","out","at","index","Fragment","RefText"],"mappings":";;;AA2DA,MAAMA,IAAmBC,EAAgC,IAAI,GAEhDC,IAAkBD,EAA+B,IAAI;AAG3D,SAASE,EAAuB,EAAE,SAAAC,GAAS,SAAAC,GAAS,WAAAC,GAAW,UAAAC,KAAyC;AAC7G,MAAI,CAACH,EAAQ;AACX,UAAM,IAAI,MAAM,iFAAiF;AAEnG,QAAMI,IAAQC,EAAQ,OAAO,EAAE,SAAAL,GAAS,SAAAC,GAAS,WAAAC,EAAA,IAA2B,CAACF,GAASC,GAASC,CAAS,CAAC;AACzG,SAAO,gBAAAI,EAACV,EAAiB,UAAjB,EAA0B,OAAAQ,GAAe,UAAAD,EAAA,CAAS;AAC5D;AAKA,SAASI,EAAUC,GAAcR,GAAwD;AAGvF,QAAMS,IAA+C,CAAA;AACrD,aAAWC,KAAKF,EAAK,SAAS,IAAI,OAAOR,EAAQ,QAAQA,EAAQ,KAAK,CAAC;AACrE,IAAIU,EAAE,CAAC,MAAM,QAAU,KAAK,EAAE,KAAKA,EAAE,CAAC,GAAG,OAAOA,EAAE,OAAO;AAE3D,SAAOD;AACT;AAEA,SAASE,EAAYC,GAA4BC,GAAqC;AACpF,aAAWC,KAAQF;AACjB,IAAIE,EAAK,SAAS,SAAQD,EAAMC,EAAK,KAAK,KACjCA,EAAK,SAAS,cAAcA,EAAK,SAAS,YAAYA,EAAK,SAAS,aAAUH,EAAYG,EAAK,UAAUD,CAAK;AAG3H;AAEA,SAASE,EAAWH,GAA0BC,GAAqC;AACjF,aAAWC,KAAQF;AACjB,YAAQE,EAAK,MAAA;AAAA,MACX,KAAK;AAAA,MACL,KAAK;AACH,QAAAH,EAAYG,EAAK,UAAUD,CAAK;AAChC;AAAA,MACF,KAAK;AACH,QAAAE,EAAWD,EAAK,UAAUD,CAAK;AAC/B;AAAA,MACF,KAAK;AACH,mBAAWG,KAAQF,EAAK,MAAO,CAAAC,EAAWC,EAAK,UAAUH,CAAK;AAC9D;AAAA,MACF,KAAK;AACH,mBAAWI,KAAQH,EAAK,KAAM,CAAAH,EAAYM,EAAK,UAAUJ,CAAK;AAC9D,mBAAWK,KAAOJ,EAAK,KAAM,YAAWG,KAAQC,EAAK,CAAAP,EAAYM,EAAK,UAAUJ,CAAK;AACrF;AAAA,MACF,KAAK;AACH,mBAAWG,KAAQF,EAAK,MAAO,CAAAC,EAAWC,EAAK,UAAUH,CAAK;AAC9D;AAAA,IAIA;AAGR;AAEA,SAASM,EAAaC,GAAoCpB,GAA2B;AACnF,QAAMqB,wBAAW,IAAA,GACXR,IAAQ,CAACL,MAAiB;AAC9B,eAAW,EAAE,KAAAc,OAASf,EAAUC,GAAMR,CAAO,EAAG,CAAAqB,EAAK,IAAIC,CAAG;AAAA,EAC9D;AACA,SAAI,OAAOF,KAAW,WAAUP,EAAMO,CAAM,IACvCL,EAAWK,GAAQP,CAAK,GACtB,CAAC,GAAGQ,CAAI;AACjB;AAIA,MAAME,wBAAyC,IAAA;AAMxC,SAASC,EAAYJ,GAAqD;AAC/E,QAAMK,IAASC,EAAW9B,CAAgB,GACpCI,IAAUyB,GAAQ,SAClBE,IAAatB,EAAQ,MAAOL,IAAUmB,EAAaC,GAAQpB,CAAO,IAAI,CAAA,GAAK,CAACoB,GAAQpB,CAAO,CAAC,GAG5F4B,IAASC,EAAqBC,GAAmBC,GAAsBA,CAAoB,GAC3F,CAACC,GAASC,CAAU,IAAIC,EAAiE,EAAE,QAAAN,GAAQ,KAAKL,GAAM,GAC9GY,IAAWH,EAAQ,WAAWJ,IAASI,EAAQ,MAAMT,GACrDa,IAAQC,EAAO,oBAAI,KAAa,GAChCC,IAAQD,EAA+B,IAAI,GAC3CE,IAAaF,EAAOZ,GAAQ,OAAO;AACzC,SAAAc,EAAW,UAAUd,GAAQ,SAM7Be,EAAU,OACRF,EAAM,UAAU,IAAI,gBAAA,GACb,MAAM;AACX,IAAAA,EAAM,SAAS,MAAA,GACfF,EAAM,QAAQ,MAAA;AAAA,EAChB,IACC,CAACR,CAAM,CAAC,GAEXY,EAAU,MAAM;AACd,UAAMvC,IAAUsC,EAAW,SACrBE,IAASH,EAAM,SAAS,QACxBI,IAAQf,EAAW,OAAO,CAACL,MAAQ,CAACc,EAAM,QAAQ,IAAId,CAAG,CAAC;AAChE,QAAI,GAACrB,KAAW,CAACwC,KAAUC,EAAM,WAAW,IAC5C;AAAA,iBAAWpB,KAAOoB,EAAO,CAAAN,EAAM,QAAQ,IAAId,CAAG;AAC9C,MAAArB,EAAQyC,GAAOD,CAAM,EAAE;AAAA,QACrB,CAAChC,MAAU;AACT,UAAKgC,EAAO,WACVR,EAAW,CAACU,OAAU,EAAE,QAAAf,GAAQ,KAAK,IAAI,IAAI,CAAC,GAAIe,EAAK,WAAWf,IAASe,EAAK,MAAMpB,GAAO,GAAGd,CAAK,CAAC,IAAI;AAAA,QAE9G;AAAA,QACA,CAACmC,MAAmB;AAClB,cAAI,CAAAH,EAAO,SAEX;AAAA,uBAAWnB,KAAOoB,EAAO,CAAAN,EAAM,QAAQ,OAAOd,CAAG;AACjD,kBAAMsB;AAAA;AAAA,QACR;AAAA,MAAA;AAAA;AAAA,EAEJ,GAAG,CAACjB,GAAYC,CAAM,CAAC,GAEhBvB;AAAA,IACL,MAAOoB,IAAS,EAAE,SAASA,EAAO,SAAS,UAAAU,GAAU,WAAWV,EAAO,UAAA,IAAc;AAAA,IACrF,CAACA,GAAQU,CAAQ;AAAA,EAAA;AAErB;AAKO,SAASU,EAASrC,GAAcsC,GAAmC;AACxE,MAAI,CAACA,KAASA,EAAM,SAAS,SAAS,EAAG,QAAOtC;AAChD,QAAMuC,IAAmB,CAAA;AACzB,MAAIC,IAAK;AACT,aAAW,EAAE,KAAA1B,GAAK,OAAA2B,EAAA,KAAW1C,EAAUC,GAAMsC,EAAM,OAAO;AACxD,IAAKA,EAAM,SAAS,IAAIxB,CAAG,MACvB2B,IAAQD,KAAID,EAAI,KAAKvC,EAAK,MAAMwC,GAAIC,CAAK,CAAC,GAC9CF,EAAI,KAAK,gBAAAzC,EAAC4C,GAAA,EAAsB,YAAM,UAAU5B,GAAKwB,EAAM,SAAS,IAAIxB,CAAG,CAAC,EAAA,GAApD2B,CAAsD,CAAW,GACzFD,IAAKC,IAAQ3B,EAAI;AAEnB,SAAIyB,EAAI,WAAW,IAAUvC,KACzBwC,IAAKxC,EAAK,UAAQuC,EAAI,KAAKvC,EAAK,MAAMwC,CAAE,CAAC,GACtCD;AACT;AAMO,SAASI,EAAQ,EAAE,UAAAhD,KAAkC;AAC1D,QAAM2C,IAAQtB,EAAYrB,CAAQ;AAClC,SAAO,gBAAAG,EAAA4C,GAAA,EAAG,UAAAL,EAAS1C,GAAU2C,CAAK,GAAE;AACtC;"}

package/dist/lib/syntax/markdown/render.js

@@ -0,0 +1,230 @@
+import { jsx as r, Fragment as o, jsxs as d } from "react/jsx-runtime";
+import { useContext as y, useState as N } from "react";
+import { Dialog as w } from "../../../components/Dialog.js";
+import { Tooltip as v } from "../../../components/Popover.js";
+import { cn as i } from "../../cn.js";
+import { useRefLinks as I, RefLinksContext as p, linkRefs as R } from "./refs.js";
+import { useUiStrings as u } from "../../i18n/provider.js";
+function x({ title: e, children: t }) {
+  return e ? /* @__PURE__ */ r(v, { content: e, children: t }) : t;
+}
+function H({ nodes: e, renderCode: t }) {
+  const n = I(e);
+  return /* @__PURE__ */ r(p.Provider, { value: n, children: /* @__PURE__ */ r(m, { nodes: e, renderCode: t }) });
+}
+function m({ nodes: e, renderCode: t }) {
+  return e.map((n, l) => /* @__PURE__ */ r(L, { node: n, renderCode: t }, l));
+}
+const z = {
+  1: "text-xl",
+  2: "text-lg",
+  3: "text-base",
+  4: "text-sm",
+  5: "text-sm",
+  6: "text-xs uppercase tracking-wide text-secondary"
+};
+function L({ node: e, renderCode: t }) {
+  switch (e.kind) {
+    case "heading": {
+      const n = `h${e.level}`;
+      return /* @__PURE__ */ r(
+        n,
+        {
+          id: e.id,
+          className: i(
+            "mt-4 mb-1 scroll-mt-4 font-display font-semibold text-primary first:mt-0",
+            z[e.level]
+          ),
+          children: /* @__PURE__ */ r(c, { nodes: e.children })
+        }
+      );
+    }
+    case "paragraph":
+      return /* @__PURE__ */ r("p", { className: "my-1.5 first:mt-0 last:mb-0", children: /* @__PURE__ */ r(c, { nodes: e.children }) });
+    case "code":
+      return /* @__PURE__ */ r(o, { children: t(e) });
+    /* Front matter is a code block that happens to sit at the top of the file,
+       so it renders through the same consumer-supplied renderer — which is also
+       what gets it highlighted as YAML rather than shown as grey prose. */
+    case "frontmatter":
+      return /* @__PURE__ */ r(o, { children: t({ language: e.language, code: e.body, open: !1 }) });
+    case "quote":
+      return /* @__PURE__ */ r("blockquote", { className: "my-2 border-l-2 border-accent-border pl-3 text-secondary italic", children: /* @__PURE__ */ r(m, { nodes: e.children, renderCode: t }) });
+    case "rule":
+      return /* @__PURE__ */ r("hr", { className: "my-3 border-0 border-t border-border-subtle" });
+    case "list":
+      return /* @__PURE__ */ r(S, { node: e, renderCode: t });
+    case "table":
+      return /* @__PURE__ */ r($, { node: e });
+    case "footnotes":
+      return /* @__PURE__ */ r(A, { node: e, renderCode: t });
+  }
+}
+function S({
+  node: e,
+  renderCode: t
+}) {
+  const n = e.ordered ? "ol" : "ul", l = e.items.some((s) => s.checked !== null);
+  return /* @__PURE__ */ r(
+    n,
+    {
+      start: e.ordered && e.start !== 1 ? e.start : void 0,
+      className: i(
+        "my-1.5 flex flex-col pl-5 marker:text-tertiary",
+        e.tight ? "gap-1" : "gap-2",
+        /* A checkbox IS the marker. Leaving the disc in place gives every task
+           two bullets, one of which does nothing. */
+        l ? "list-none pl-1" : e.ordered ? "list-decimal" : "list-disc"
+      ),
+      children: e.items.map((s, a) => /* @__PURE__ */ r(T, { item: s, tight: e.tight, renderCode: t }, a))
+    }
+  );
+}
+function T({
+  item: e,
+  tight: t,
+  renderCode: n
+}) {
+  const l = u().markdownRender, s = e.children.length === 1 ? e.children[0] : null, a = t && s && s.kind === "paragraph" ? /* @__PURE__ */ r(c, { nodes: s.children }) : /* @__PURE__ */ r(m, { nodes: e.children, renderCode: n });
+  return e.checked === null ? /* @__PURE__ */ r("li", { className: "pl-0.5", children: a }) : /* @__PURE__ */ d("li", { className: "flex items-baseline gap-2 pl-0.5", children: [
+    /* @__PURE__ */ r(
+      "input",
+      {
+        type: "checkbox",
+        checked: e.checked,
+        readOnly: !0,
+        disabled: !0,
+        "aria-label": e.checked ? l.done : l.notDone,
+        className: "mt-0.5 size-3.5 shrink-0 accent-accent"
+      }
+    ),
+    /* @__PURE__ */ r("span", { className: i("min-w-0 flex-1", e.checked && "text-tertiary line-through"), children: a })
+  ] });
+}
+const h = {
+  left: "text-left",
+  center: "text-center",
+  right: "text-right"
+};
+function $({ node: e }) {
+  const t = u().markdownRender;
+  return (
+    /* Focusable because it scrolls sideways. A region that can only be panned
+       with a pointer is unreachable by keyboard, and a wide table is the most
+       common place that happens. */
+    /* @__PURE__ */ r(
+      "div",
+      {
+        tabIndex: 0,
+        role: "region",
+        "aria-label": t.table,
+        className: "my-2 overflow-x-auto rounded-lg border border-border-subtle outline-none focus-visible:ring-2 focus-visible:ring-focus-ring",
+        children: /* @__PURE__ */ d("table", { className: "w-full border-collapse text-xs", children: [
+          /* @__PURE__ */ r("thead", { children: /* @__PURE__ */ r("tr", { children: e.head.map((n, l) => /* @__PURE__ */ r(
+            "th",
+            {
+              scope: "col",
+              className: i(
+                "border-b border-border-subtle bg-surface-inset px-3 py-1.5 font-semibold text-primary",
+                h[e.align[l] ?? "left"]
+              ),
+              children: /* @__PURE__ */ r(c, { nodes: n.children })
+            },
+            l
+          )) }) }),
+          /* @__PURE__ */ r("tbody", { children: e.rows.map((n, l) => /* @__PURE__ */ r("tr", { children: n.map((s, a) => /* @__PURE__ */ r(
+            "td",
+            {
+              className: i(
+                "border-b border-border-subtle px-3 py-1.5 text-secondary last:border-b-0",
+                h[e.align[a] ?? "left"]
+              ),
+              children: /* @__PURE__ */ r(c, { nodes: s.children })
+            },
+            a
+          )) }, l)) })
+        ] })
+      }
+    )
+  );
+}
+function A({
+  node: e,
+  renderCode: t
+}) {
+  const n = u().markdownRender;
+  return /* @__PURE__ */ r("section", { "aria-label": n.footnotes, className: "mt-4 border-t border-border-subtle pt-2 text-xs text-tertiary", children: /* @__PURE__ */ r("ol", { className: "flex list-decimal flex-col gap-1 pl-5 marker:text-tertiary", children: e.items.map((l) => /* @__PURE__ */ d("li", { id: g(l.label), children: [
+    /* @__PURE__ */ r(m, { nodes: l.children, renderCode: t }),
+    " ",
+    /* @__PURE__ */ r("a", { href: `#${k(l.label)}`, "aria-label": n.backToReference, className: "text-accent-text", children: "↩" })
+  ] }, l.label)) }) });
+}
+const g = (e) => `fn-${e}`, k = (e) => `fnref-${e}`, D = "rounded-[4px] border border-border-subtle bg-surface-inset px-1 py-px font-mono text-[0.88em] text-primary", f = "text-accent-text underline decoration-accent-border underline-offset-2 transition-colors duration-(--dur-fast) hover:decoration-accent";
+function c({ nodes: e, linked: t = !0 }) {
+  return e.map((n, l) => /* @__PURE__ */ r(O, { node: n, linked: t }, l));
+}
+function O({ node: e, linked: t }) {
+  const n = y(p);
+  switch (e.kind) {
+    case "text":
+      return /* @__PURE__ */ r(o, { children: R(e.value, t ? n : null) });
+    case "code":
+      return /* @__PURE__ */ r("code", { className: D, children: e.value });
+    case "emphasis":
+      return /* @__PURE__ */ r("em", { children: /* @__PURE__ */ r(c, { nodes: e.children, linked: t }) });
+    case "strong":
+      return /* @__PURE__ */ r("strong", { className: "font-semibold text-primary", children: /* @__PURE__ */ r(c, { nodes: e.children, linked: t }) });
+    case "strike":
+      return /* @__PURE__ */ r("del", { className: "text-tertiary", children: /* @__PURE__ */ r(c, { nodes: e.children, linked: t }) });
+    case "break":
+      return /* @__PURE__ */ r("br", {});
+    case "footnoteRef":
+      return /* @__PURE__ */ r("sup", { id: k(e.label), children: /* @__PURE__ */ r("a", { href: `#${g(e.label)}`, className: f, children: e.label }) });
+    case "image": {
+      const l = b(e.src);
+      return l ? /* @__PURE__ */ r(_, { src: l, alt: e.alt, title: e.title }) : /* @__PURE__ */ r("span", { className: "text-tertiary italic", children: e.alt });
+    }
+    case "link": {
+      const l = b(e.href);
+      if (!l)
+        return /* @__PURE__ */ r("span", { "data-unsafe-href": "", children: /* @__PURE__ */ r(c, { nodes: e.children, linked: !1 }) });
+      const s = /^[a-z][a-z0-9+.-]*:/i.test(l);
+      return /* @__PURE__ */ r(x, { title: e.title, children: /* @__PURE__ */ r(
+        "a",
+        {
+          href: l,
+          target: s ? "_blank" : void 0,
+          rel: s ? "noreferrer noopener" : void 0,
+          className: f,
+          children: /* @__PURE__ */ r(c, { nodes: e.children, linked: !1 })
+        }
+      ) });
+    }
+  }
+}
+function _({ src: e, alt: t, title: n }) {
+  const l = u().markdownRender, [s, a] = N(!1);
+  return /* @__PURE__ */ d(o, { children: [
+    /* @__PURE__ */ r(x, { title: n, children: /* @__PURE__ */ r(
+      "img",
+      {
+        src: e,
+        alt: t,
+        loading: "lazy",
+        decoding: "async",
+        onClick: () => a(!0),
+        className: "my-2 max-h-40 w-auto max-w-full cursor-zoom-in rounded-lg border border-border-subtle"
+      }
+    ) }),
+    /* @__PURE__ */ r(w, { open: s, onOpenChange: a, title: t || l.image, size: "xl", children: /* @__PURE__ */ r("img", { src: e, alt: t, className: "max-w-full rounded-lg" }) })
+  ] });
+}
+function b(e) {
+  const n = e.trim().replace(/[\u0000-\u0020]/g, "");
+  return /^[a-z][a-z0-9+.-]*:/i.test(n) ? /^(https?|mailto|tel|ftp):/i.test(n) ? n : null : n;
+}
+export {
+  H as MarkdownNodes,
+  b as sanitizeHref
+};
+//# sourceMappingURL=render.js.map

package/dist/lib/syntax/markdown/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sources":["../../../../src/lib/syntax/markdown/render.tsx"],"sourcesContent":["import { useContext, useState, type ReactElement, type ReactNode } from \"react\";\nimport { Dialog } from \"../../../components/Dialog\";\nimport { Tooltip } from \"../../../components/Popover\";\nimport { cn } from \"../../cn\";\nimport { useUiStrings } from \"../../i18n\";\nimport { linkRefs, RefLinksContext, useRefLinks } from \"./refs\";\nimport type { MdAlign, MdCell, MdCodeRenderer, MdInline, MdListItem, MdNode } from \"./types\";\n\n/**\n * Markdown's link and image `title` becomes a real Tooltip, never the native\n * `title=` attribute.\n *\n * The native one is banned system-wide (D-24) and every reason applies here:\n * it ignores the theme, never appears on touch, and is read inconsistently by\n * screen readers — so the supplementary text an author deliberately wrote is\n * invisible to a large share of the people reading it. There is a source sweep\n * that fails the build on any lowercase element carrying it.\n *\n * A title is rare, so the Tooltip is mounted only when one exists and ordinary\n * links cost nothing.\n */\nfunction Titled({ title, children }: { title?: string; children: ReactElement }): ReactNode {\n  return title ? <Tooltip content={title}>{children}</Tooltip> : children;\n}\n\n/* ============================================================================\n   MARKDOWN RENDERER — React elements from the tree, and nothing else.\n\n   RULE ONE: React elements, never `dangerouslySetInnerHTML`. Markdown is the\n   format you receive from somewhere else — a chat reply, a card description, a\n   file on disk — which makes it the single place a component library must not\n   trust its input. The escape hatch is not merely unused here, it is absent,\n   and the parser upstream never produces raw HTML for it to use: `<div>` in the\n   source arrives as the literal text `<div>`.\n\n   RULE TWO: every href and every image src goes through `sanitizeHref`.\n   `javascript:` and `data:text/html` are working attacks against any renderer\n   that passes a URL through untouched, and the interesting cases are the ones\n   that do not look like attacks — `JaVaScRiPt:` and a tab inside the scheme\n   both survive a naive prefix test and both execute.\n\n   RULE THREE: `renderCode` is a PROP. This module must not import the\n   `CodeEditor` component, because `CodeEditor` renders markdown — the import would be a cycle.\n   Handing the fence renderer in also means a chat bubble and a docs page can\n   present the same block differently without either of them forking this file.\n\n   Every colour here is a semantic token utility (`text-primary`, `bg-surface-\n   inset`, `border-border-subtle`). A raw palette class like `bg-slate-800` is a\n   bug in this repo: it survives the light theme and inverts nothing.\n   ========================================================================= */\n\nexport interface MarkdownNodesProps {\n  nodes: MdNode[];\n  /** How a fenced block renders. Supplied by the consumer to avoid a cycle. */\n  renderCode: MdCodeRenderer;\n}\n\n/**\n * The document. It owns the resource-ref scope (DXUI-32): the refs of the whole\n * tree are collected and resolved once here, and every inline beneath reads the\n * answer from context. Nested block lists (quote, list item, footnote) use\n * `Blocks`, so a document is one scope however deeply it nests.\n */\nexport function MarkdownNodes({ nodes, renderCode }: MarkdownNodesProps): ReactNode {\n  const links = useRefLinks(nodes);\n  return (\n    <RefLinksContext.Provider value={links}>\n      <Blocks nodes={nodes} renderCode={renderCode} />\n    </RefLinksContext.Provider>\n  );\n}\n\nfunction Blocks({ nodes, renderCode }: MarkdownNodesProps): ReactNode {\n  return nodes.map((node, i) => <Block key={i} node={node} renderCode={renderCode} />);\n}\n\n/* --- Blocks --------------------------------------------------------------- */\n\nconst HEADING_SIZE: Record<number, string> = {\n  1: \"text-xl\",\n  2: \"text-lg\",\n  3: \"text-base\",\n  4: \"text-sm\",\n  5: \"text-sm\",\n  6: \"text-xs uppercase tracking-wide text-secondary\",\n};\n\nfunction Block({ node, renderCode }: { node: MdNode; renderCode: MdCodeRenderer }): ReactNode {\n  switch (node.kind) {\n    case \"heading\": {\n      const Tag = `h${node.level}` as \"h1\";\n      return (\n        <Tag\n          id={node.id}\n          className={cn(\n            \"mt-4 mb-1 scroll-mt-4 font-display font-semibold text-primary first:mt-0\",\n            HEADING_SIZE[node.level],\n          )}\n        >\n          <Inlines nodes={node.children} />\n        </Tag>\n      );\n    }\n\n    case \"paragraph\":\n      return (\n        <p className=\"my-1.5 first:mt-0 last:mb-0\">\n          <Inlines nodes={node.children} />\n        </p>\n      );\n\n    case \"code\":\n      return <>{renderCode(node)}</>;\n\n    /* Front matter is a code block that happens to sit at the top of the file,\n       so it renders through the same consumer-supplied renderer — which is also\n       what gets it highlighted as YAML rather than shown as grey prose. */\n    case \"frontmatter\":\n      return <>{renderCode({ language: node.language, code: node.body, open: false })}</>;\n\n    case \"quote\":\n      return (\n        <blockquote className=\"my-2 border-l-2 border-accent-border pl-3 text-secondary italic\">\n          <Blocks nodes={node.children} renderCode={renderCode} />\n        </blockquote>\n      );\n\n    case \"rule\":\n      return <hr className=\"my-3 border-0 border-t border-border-subtle\" />;\n\n    case \"list\":\n      return <List node={node} renderCode={renderCode} />;\n\n    case \"table\":\n      return <Table node={node} />;\n\n    case \"footnotes\":\n      return <Footnotes node={node} renderCode={renderCode} />;\n  }\n}\n\nfunction List({\n  node,\n  renderCode,\n}: {\n  node: Extract<MdNode, { kind: \"list\" }>;\n  renderCode: MdCodeRenderer;\n}): ReactNode {\n  const Tag = node.ordered ? \"ol\" : \"ul\";\n  const tasks = node.items.some((item) => item.checked !== null);\n\n  return (\n    <Tag\n      start={node.ordered && node.start !== 1 ? node.start : undefined}\n      className={cn(\n        \"my-1.5 flex flex-col pl-5 marker:text-tertiary\",\n        node.tight ? \"gap-1\" : \"gap-2\",\n        /* A checkbox IS the marker. Leaving the disc in place gives every task\n           two bullets, one of which does nothing. */\n        tasks ? \"list-none pl-1\" : node.ordered ? \"list-decimal\" : \"list-disc\",\n      )}\n    >\n      {node.items.map((item, i) => (\n        <Item key={i} item={item} tight={node.tight} renderCode={renderCode} />\n      ))}\n    </Tag>\n  );\n}\n\nfunction Item({\n  item,\n  tight,\n  renderCode,\n}: {\n  item: MdListItem;\n  tight: boolean;\n  renderCode: MdCodeRenderer;\n}): ReactNode {\n  const strings = useUiStrings().markdownRender;\n  /* A tight item's single paragraph renders WITHOUT the `<p>`: that wrapper is\n     what puts a blank line between every bullet, and the difference between a\n     tight and a loose list is exactly this. */\n  const only = item.children.length === 1 ? item.children[0] : null;\n  const body =\n    tight && only && only.kind === \"paragraph\" ? (\n      <Inlines nodes={only.children} />\n    ) : (\n      <Blocks nodes={item.children} renderCode={renderCode} />\n    );\n\n  if (item.checked === null) return <li className=\"pl-0.5\">{body}</li>;\n\n  return (\n    <li className=\"flex items-baseline gap-2 pl-0.5\">\n      <input\n        type=\"checkbox\"\n        checked={item.checked}\n        readOnly\n        disabled\n        aria-label={item.checked ? strings.done : strings.notDone}\n        className=\"mt-0.5 size-3.5 shrink-0 accent-accent\"\n      />\n      <span className={cn(\"min-w-0 flex-1\", item.checked && \"text-tertiary line-through\")}>{body}</span>\n    </li>\n  );\n}\n\nconst ALIGN: Record<MdAlign, string> = {\n  left: \"text-left\",\n  center: \"text-center\",\n  right: \"text-right\",\n};\n\nfunction Table({ node }: { node: Extract<MdNode, { kind: \"table\" }> }): ReactNode {\n  const strings = useUiStrings().markdownRender;\n  return (\n    /* Focusable because it scrolls sideways. A region that can only be panned\n       with a pointer is unreachable by keyboard, and a wide table is the most\n       common place that happens. */\n    <div\n      tabIndex={0}\n      role=\"region\"\n      aria-label={strings.table}\n      className=\"my-2 overflow-x-auto rounded-lg border border-border-subtle outline-none focus-visible:ring-2 focus-visible:ring-focus-ring\"\n    >\n      <table className=\"w-full border-collapse text-xs\">\n        <thead>\n          <tr>\n            {node.head.map((cell, i) => (\n              <th\n                key={i}\n                scope=\"col\"\n                className={cn(\n                  \"border-b border-border-subtle bg-surface-inset px-3 py-1.5 font-semibold text-primary\",\n                  ALIGN[node.align[i] ?? \"left\"],\n                )}\n              >\n                <Inlines nodes={cell.children} />\n              </th>\n            ))}\n          </tr>\n        </thead>\n        <tbody>\n          {node.rows.map((row, r) => (\n            <tr key={r}>\n              {row.map((cell: MdCell, c) => (\n                <td\n                  key={c}\n                  className={cn(\n                    \"border-b border-border-subtle px-3 py-1.5 text-secondary last:border-b-0\",\n                    ALIGN[node.align[c] ?? \"left\"],\n                  )}\n                >\n                  <Inlines nodes={cell.children} />\n                </td>\n              ))}\n            </tr>\n          ))}\n        </tbody>\n      </table>\n    </div>\n  );\n}\n\nfunction Footnotes({\n  node,\n  renderCode,\n}: {\n  node: Extract<MdNode, { kind: \"footnotes\" }>;\n  renderCode: MdCodeRenderer;\n}): ReactNode {\n  const strings = useUiStrings().markdownRender;\n  return (\n    <section aria-label={strings.footnotes} className=\"mt-4 border-t border-border-subtle pt-2 text-xs text-tertiary\">\n      <ol className=\"flex list-decimal flex-col gap-1 pl-5 marker:text-tertiary\">\n        {node.items.map((item) => (\n          <li key={item.label} id={footnoteId(item.label)}>\n            <Blocks nodes={item.children} renderCode={renderCode} />{\" \"}\n            {/* The return link is what makes footnotes usable at all: without it\n                a reader who followed a reference has no way back to the sentence\n                they left. */}\n            <a href={`#${footnoteRefId(item.label)}`} aria-label={strings.backToReference} className=\"text-accent-text\">\n              ↩\n            </a>\n          </li>\n        ))}\n      </ol>\n    </section>\n  );\n}\n\nconst footnoteId = (label: string) => `fn-${label}`;\nconst footnoteRefId = (label: string) => `fnref-${label}`;\n\n/* --- Inlines -------------------------------------------------------------- */\n\nconst CODE_CLASS =\n  \"rounded-[4px] border border-border-subtle bg-surface-inset px-1 py-px font-mono text-[0.88em] text-primary\";\nconst LINK_CLASS =\n  \"text-accent-text underline decoration-accent-border underline-offset-2 transition-colors duration-(--dur-fast) hover:decoration-accent\";\n\n/** `linked` is false inside a link's label: an anchor never holds another one. */\nfunction Inlines({ nodes, linked = true }: { nodes: MdInline[]; linked?: boolean }): ReactNode {\n  return nodes.map((node, i) => <Inline key={i} node={node} linked={linked} />);\n}\n\nfunction Inline({ node, linked }: { node: MdInline; linked: boolean }): ReactNode {\n  const links = useContext(RefLinksContext);\n  switch (node.kind) {\n    case \"text\":\n      return <>{linkRefs(node.value, linked ? links : null)}</>;\n\n    case \"code\":\n      return <code className={CODE_CLASS}>{node.value}</code>;\n\n    case \"emphasis\":\n      return (\n        <em>\n          <Inlines nodes={node.children} linked={linked} />\n        </em>\n      );\n\n    case \"strong\":\n      return (\n        <strong className=\"font-semibold text-primary\">\n          <Inlines nodes={node.children} linked={linked} />\n        </strong>\n      );\n\n    case \"strike\":\n      return (\n        <del className=\"text-tertiary\">\n          <Inlines nodes={node.children} linked={linked} />\n        </del>\n      );\n\n    case \"break\":\n      return <br />;\n\n    case \"footnoteRef\":\n      return (\n        <sup id={footnoteRefId(node.label)}>\n          <a href={`#${footnoteId(node.label)}`} className={LINK_CLASS}>\n            {node.label}\n          </a>\n        </sup>\n      );\n\n    case \"image\": {\n      const src = sanitizeHref(node.src);\n      /* An image with a rejected src renders as its alt text. Rendering a\n         broken `<img>` would hide the fact that something was filtered. */\n      if (!src) return <span className=\"text-tertiary italic\">{node.alt}</span>;\n      return <MarkdownImage src={src} alt={node.alt} title={node.title} />;\n    }\n\n    case \"link\": {\n      const href = sanitizeHref(node.href);\n      /* A rejected scheme renders as TEXT, not as a dead anchor. An anchor that\n         looks like a link and does nothing teaches people to click harder; the\n         label survives so the attempt is still visible in the prose. */\n      if (!href) {\n        return (\n          <span data-unsafe-href=\"\">\n            <Inlines nodes={node.children} linked={false} />\n          </span>\n        );\n      }\n      const external = /^[a-z][a-z0-9+.-]*:/i.test(href);\n      return (\n        <Titled title={node.title}>\n          <a\n            href={href}\n            target={external ? \"_blank\" : undefined}\n            rel={external ? \"noreferrer noopener\" : undefined}\n            className={LINK_CLASS}\n          >\n            <Inlines nodes={node.children} linked={false} />\n          </a>\n        </Titled>\n      );\n    }\n  }\n}\n\n/**\n * An inline image, capped to a compact thumbnail and click-to-enlarge.\n *\n * A screenshot dropped into a markdown field (a card comment, a problem\n * statement, a plan record) is the most common image this renders, and an\n * uncapped one would blow past the width of any of those surfaces and,\n * worse, a TALL one (a full-page screenshot) would still run on forever even\n * with a width cap alone — hence a HEIGHT cap here, not a width cap, with\n * `w-auto` left free to shrink for a narrow source image.\n *\n * Clicking opens the full-resolution image in a `Dialog` rather than\n * navigating or replacing the thumbnail in place, so the surrounding prose\n * never loses its layout while the image is being inspected.\n */\nfunction MarkdownImage({ src, alt, title }: { src: string; alt: string; title?: string }): ReactNode {\n  const strings = useUiStrings().markdownRender;\n  const [open, setOpen] = useState(false);\n\n  return (\n    <>\n      <Titled title={title}>\n        <img\n          src={src}\n          alt={alt}\n          loading=\"lazy\"\n          decoding=\"async\"\n          onClick={() => setOpen(true)}\n          className=\"my-2 max-h-40 w-auto max-w-full cursor-zoom-in rounded-lg border border-border-subtle\"\n        />\n      </Titled>\n      <Dialog open={open} onOpenChange={setOpen} title={alt || strings.image} size=\"xl\">\n        <img src={src} alt={alt} className=\"max-w-full rounded-lg\" />\n      </Dialog>\n    </>\n  );\n}\n\n/**\n * RULE TWO, the implementation: a link's scheme is checked before it is\n * rendered.\n *\n * `[click](javascript:fetch('/api/keys').then(…))` is a working attack against\n * every renderer that passes href through untouched, and `data:text/html` is\n * the same hole wearing a different scheme. Anything not on the allowed list\n * returns null, and the caller renders the label as plain text rather than\n * dropping it — silently swallowing it would hide the attempt.\n */\nexport function sanitizeHref(href: string): string | null {\n  const trimmed = href.trim();\n  /* Control characters are stripped first: `java\\tscript:` is parsed as\n     `javascript:` by browsers but not by a naive prefix test. */\n  const clean = trimmed.replace(/[\\u0000-\\u0020]/g, \"\");\n  if (/^[a-z][a-z0-9+.-]*:/i.test(clean)) {\n    return /^(https?|mailto|tel|ftp):/i.test(clean) ? clean : null;\n  }\n  /* Relative, protocol-relative, fragment and query hrefs carry no scheme and\n     cannot execute. */\n  return clean;\n}\n"],"names":["Titled","title","children","jsx","Tooltip","MarkdownNodes","nodes","renderCode","links","useRefLinks","RefLinksContext","Blocks","node","i","Block","HEADING_SIZE","Tag","cn","Inlines","Fragment","List","Table","Footnotes","tasks","item","Item","tight","strings","useUiStrings","only","body","jsxs","ALIGN","cell","row","r","c","footnoteId","footnoteRefId","label","CODE_CLASS","LINK_CLASS","linked","Inline","useContext","linkRefs","src","sanitizeHref","MarkdownImage","href","external","alt","open","setOpen","useState","Dialog","clean"],"mappings":"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"}

package/dist/lib/syntax/markdown/spans.js

@@ -0,0 +1,40 @@
+function u(e) {
+  const a = [];
+  let n = "";
+  for (let t = 0; t < e.length; t++) {
+    t > 0 && (n += `
+`);
+    const r = n.length;
+    n += e[t].text, n.length > r && a.push({ ja: r, jb: n.length, sa: e[t].start });
+  }
+  return { text: n, parts: a };
+}
+function c(e) {
+  return u([e]);
+}
+function f(e, a, n) {
+  const t = [];
+  for (const r of e.parts) {
+    if (r.jb <= a) continue;
+    if (r.ja >= n) break;
+    const o = Math.max(a, r.ja), s = Math.min(n, r.jb);
+    s > o && t.push({ start: r.sa + (o - r.ja), end: r.sa + (s - r.ja) });
+  }
+  return t;
+}
+function i(e, a, n) {
+  const t = f(e, a, n);
+  return t.length ? { start: t[0].start, end: t[t.length - 1].end } : null;
+}
+function l(e, a, n, t, r) {
+  if (!(!a || t <= n))
+    for (const o of f(e, n, t)) a.span(o.start, o.end, r);
+}
+export {
+  i as hullOf,
+  u as makeSegments,
+  f as mapRange,
+  l as markRange,
+  c as segmentOf
+};
+//# sourceMappingURL=spans.js.map

package/dist/lib/syntax/markdown/spans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spans.js","sources":["../../../../src/lib/syntax/markdown/spans.ts"],"sourcesContent":["/* ============================================================================\n   SPANS — the one thing that lets a parse tree and a token list come out of a\n   SINGLE pass over the document.\n\n   THE PROBLEM. Markdown is the only language here that parses into a tree, but\n   the editor still needs a flat `Token[]` covering the source exactly. Deriving\n   those tokens from the tree afterwards is impossible: `MdNode` carries no\n   offsets, so a second pass has to go looking for its own text with\n   `indexOf` — which finds the wrong occurrence the moment a document repeats\n   itself, and silently produces a token list that no longer lines up with the\n   textarea underneath it.\n\n   THE FIX IS A SINK. The parser is handed an optional `Sink` and reports every\n   span it consumes AS IT CONSUMES IT, while it still knows the absolute offset.\n   `parseMarkdown` passes no sink and pays nothing; the grammar passes one and\n   gets a token list from the same parse the tree came from. One parse, two\n   consumers, and no way for them to disagree about where anything is.\n\n   SEGMENTS EXIST BECAUSE INLINE TEXT IS NOT CONTIGUOUS. The content of a\n   blockquote paragraph is several source lines with `> ` cut off the front of\n   each; a list item's is several lines with their indentation removed. The\n   inline scanner wants one string, but a span in that string maps back to\n   SEVERAL disjoint source ranges. `Segments` keeps that mapping, and\n   `mapRange` is the only place a joined-text offset ever becomes a source\n   offset — so the \"off by the width of a `> ` prefix\" class of bug has exactly\n   one place it can live.\n   ========================================================================= */\n\nimport type { TokenType } from \"../types\";\nimport type { Frame, Range } from \"./frames\";\n\n/** A run of source text with the absolute offset of its first character. */\nexport interface Piece {\n  text: string;\n  start: number;\n}\n\n/**\n * Pieces joined into one string for the inline scanner, plus the map back.\n *\n * The `\"\\n\"` inserted BETWEEN pieces is synthetic — in the source those two\n * lines may be separated by a newline plus a `> ` prefix, or by nothing at all.\n * It is deliberately covered by no part, so a span crossing it maps to two\n * source ranges and the prefix in between is left for the caller to have\n * already claimed.\n */\nexport interface Segments {\n  text: string;\n  parts: ReadonlyArray<{ ja: number; jb: number; sa: number }>;\n}\n\nexport function makeSegments(pieces: Piece[]): Segments {\n  const parts: Array<{ ja: number; jb: number; sa: number }> = [];\n  let text = \"\";\n  for (let i = 0; i < pieces.length; i++) {\n    if (i > 0) text += \"\\n\";\n    const ja = text.length;\n    text += pieces[i].text;\n    /* Empty pieces carry no characters, so they can carry no mapping — an\n       entry of zero width would make `mapRange` emit a reversed token. */\n    if (text.length > ja) parts.push({ ja, jb: text.length, sa: pieces[i].start });\n  }\n  return { text, parts };\n}\n\n/** One line of prose is the common case; spelled out so callers do not build a\n    single-element array by hand at forty call sites. */\nexport function segmentOf(piece: Piece): Segments {\n  return makeSegments([piece]);\n}\n\n/**\n * Maps a joined-text range to the absolute source ranges it covers.\n *\n * Returns several ranges when the span crosses a piece boundary, and none when\n * it falls entirely on a synthetic separator.\n */\nexport function mapRange(seg: Segments, a: number, b: number): Array<{ start: number; end: number }> {\n  const out: Array<{ start: number; end: number }> = [];\n  for (const part of seg.parts) {\n    if (part.jb <= a) continue;\n    if (part.ja >= b) break;\n    const from = Math.max(a, part.ja);\n    const to = Math.min(b, part.jb);\n    if (to > from) out.push({ start: part.sa + (from - part.ja), end: part.sa + (to - part.ja) });\n  }\n  return out;\n}\n\n/**\n * Where the parser reports what it consumed.\n *\n * `span` takes ABSOLUTE source offsets — never joined-text ones — because a\n * token that is right relative to some intermediate string is a token the\n * editor cannot use. `embed` is the entire nesting feature for markdown: the\n * grammar forwards it to `ctx.sub`, and a fenced block gets highlighted in its\n * own language with no code anywhere that knows which language that is.\n */\nexport interface Sink {\n  span(start: number, end: number, type: TokenType): void;\n  embed(code: string, language: string | null, at: number): void;\n  /**\n   * Opens a structural frame. `content` names the absolute source ranges this\n   * frame holds as its own TEXT; omitting it means the frame is opaque and its\n   * children claim what they need. See ./frames.ts for why that default.\n   *\n   * Required rather than optional so a new consumer cannot silently receive\n   * spans without structure — the grammar, which genuinely wants only spans,\n   * says so with an explicit no-op rather than by omission.\n   */\n  open(frame: Frame, start: number, content?: readonly Range[]): void;\n  /**\n   * Closes the innermost frame. `content` adds ranges the frame could not know\n   * at open time — in practice its own trailing line terminator, which is not\n   * known until the reader has found where the block ends.\n   */\n  close(end: number, content?: readonly Range[]): void;\n}\n\n/**\n * The source ranges a `Segments` covers — its parts, in absolute coordinates.\n *\n * This is the whole reason frames could reuse the existing bookkeeping: a\n * block's content ranges are ALREADY computed, as the pieces it cut its\n * prefixes off to build. Deriving them a second time is how the two would drift.\n */\nexport function contentOf(seg: Segments): Range[] {\n  return seg.parts.map((part) => ({ start: part.sa, end: part.sa + (part.jb - part.ja) }));\n}\n\n/** The absolute range spanned by a joined-text range, prefixes included.\n *\n *  Deliberately the OUTER hull rather than the list `mapRange` returns: a\n *  frame's interval must contain the `> ` prefixes sitting between its pieces,\n *  or the frames those prefixes belong to would not nest inside it. The pieces\n *  themselves are what `contentOf`/`mapRange` report; this is the envelope. */\nexport function hullOf(seg: Segments, a: number, b: number): Range | null {\n  const ranges = mapRange(seg, a, b);\n  if (!ranges.length) return null;\n  return { start: ranges[0].start, end: ranges[ranges.length - 1].end };\n}\n\n/** Reports a joined-text range, split across pieces, at one token type. */\nexport function markRange(seg: Segments, sink: Sink | undefined, a: number, b: number, type: TokenType): void {\n  if (!sink || b <= a) return;\n  for (const r of mapRange(seg, a, b)) sink.span(r.start, r.end, type);\n}\n"],"names":["makeSegments","pieces","parts","text","i","ja","segmentOf","piece","mapRange","seg","b","out","part","from","to","hullOf","ranges","markRange","sink","a","type","r"],"mappings":"AAmDO,SAASA,EAAaC,GAA2B;AACtD,QAAMC,IAAuD,CAAA;AAC7D,MAAIC,IAAO;AACX,WAASC,IAAI,GAAGA,IAAIH,EAAO,QAAQG,KAAK;AACtC,IAAIA,IAAI,MAAGD,KAAQ;AAAA;AACnB,UAAME,IAAKF,EAAK;AAChB,IAAAA,KAAQF,EAAOG,CAAC,EAAE,MAGdD,EAAK,SAASE,KAAIH,EAAM,KAAK,EAAE,IAAAG,GAAI,IAAIF,EAAK,QAAQ,IAAIF,EAAOG,CAAC,EAAE,OAAO;AAAA,EAC/E;AACA,SAAO,EAAE,MAAAD,GAAM,OAAAD,EAAA;AACjB;AAIO,SAASI,EAAUC,GAAwB;AAChD,SAAOP,EAAa,CAACO,CAAK,CAAC;AAC7B;AAQO,SAASC,EAASC,GAAe,GAAWC,GAAkD;AACnG,QAAMC,IAA6C,CAAA;AACnD,aAAWC,KAAQH,EAAI,OAAO;AAC5B,QAAIG,EAAK,MAAM,EAAG;AAClB,QAAIA,EAAK,MAAMF,EAAG;AAClB,UAAMG,IAAO,KAAK,IAAI,GAAGD,EAAK,EAAE,GAC1BE,IAAK,KAAK,IAAIJ,GAAGE,EAAK,EAAE;AAC9B,IAAIE,IAAKD,KAAMF,EAAI,KAAK,EAAE,OAAOC,EAAK,MAAMC,IAAOD,EAAK,KAAK,KAAKA,EAAK,MAAME,IAAKF,EAAK,KAAK;AAAA,EAC9F;AACA,SAAOD;AACT;AAiDO,SAASI,EAAON,GAAe,GAAWC,GAAyB;AACxE,QAAMM,IAASR,EAASC,GAAK,GAAGC,CAAC;AACjC,SAAKM,EAAO,SACL,EAAE,OAAOA,EAAO,CAAC,EAAE,OAAO,KAAKA,EAAOA,EAAO,SAAS,CAAC,EAAE,IAAA,IADrC;AAE7B;AAGO,SAASC,EAAUR,GAAeS,GAAwBC,GAAWT,GAAWU,GAAuB;AAC5G,MAAI,GAACF,KAAQR,KAAKS;AAClB,eAAWE,KAAKb,EAASC,GAAKU,GAAGT,CAAC,EAAG,CAAAQ,EAAK,KAAKG,EAAE,OAAOA,EAAE,KAAKD,CAAI;AACrE;"}

package/dist/lib/syntax/registry.js

@@ -0,0 +1,55 @@
+function f(e) {
+  const t = {};
+  for (const [o, s] of Object.entries(e.states))
+    t[o] = s.map((n, c) => {
+      const i = `${e.name}.${o}[${c}]`;
+      if (n.token && n.groups)
+        throw new Error(`${i}: a rule sets both token and groups; pick one`);
+      if (n.embed && !n.until)
+        throw new Error(`${i}: embed needs until, or the region never ends`);
+      if (n.push && n.pop)
+        throw new Error(`${i}: a rule cannot push and pop at once`);
+      if (n.push && !e.states[n.push])
+        throw new Error(`${i}: pushes state "${n.push}", which does not exist`);
+      return {
+        ...n,
+        match: a(n.match),
+        until: n.until ? a(n.until) : void 0
+      };
+    });
+  if (!e.tokenize && !t.root)
+    throw new Error(`${e.name}: needs a root state or a tokenize override`);
+  return { ...e, states: t };
+}
+function a(e) {
+  let t = e.flags;
+  return t.includes("y") || (t += "y"), t.includes("d") || (t += "d"), t = t.replace("g", ""), new RegExp(e.source, t);
+}
+const r = /* @__PURE__ */ new Map();
+function h(e) {
+  const t = [e.name, ...e.aliases ?? []];
+  for (const o of t) {
+    const s = o.toLowerCase(), n = r.get(s);
+    if (n && n.name !== e.name)
+      throw new Error(`language "${o}" is claimed by both ${n.name} and ${e.name}`);
+    r.set(s, e);
+  }
+}
+function u(e) {
+  if (e)
+    return r.get(e.trim().toLowerCase());
+}
+function p(e) {
+  return u(e)?.name ?? null;
+}
+function w() {
+  return [...new Set([...r.values()].map((e) => e.name))].sort();
+}
+export {
+  f as defineGrammar,
+  u as getGrammar,
+  w as listLanguages,
+  h as registerGrammar,
+  p as resolveLanguage
+};
+//# sourceMappingURL=registry.js.map

package/dist/lib/syntax/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sources":["../../../src/lib/syntax/registry.ts"],"sourcesContent":["import type { Grammar, Rule } from \"./types\";\n\n/**\n * Normalises and checks a grammar at definition time, so a malformed rule fails\n * where it was written rather than as slightly-wrong colours in a browser.\n *\n * Every pattern is rebuilt with two flags forced on:\n *\n *   `y` (sticky) — a plain regex SEARCHES FORWARD from the position, so a rule\n *   can match text the scanner has not reached yet and silently swallow\n *   everything in between. Sticky anchors it to exactly where the scanner is.\n *\n *   `d` (hasIndices) — `groups` needs the offset of each capture, and\n *   `match.indices` is the only way to get it that survives optional groups.\n *\n * Forcing them beats throwing on their absence: a grammar author writes an\n * ordinary regex and the one thing they could get subtly wrong is unreachable.\n */\nexport function defineGrammar(grammar: Grammar): Grammar {\n  const states: Record<string, Rule[]> = {};\n\n  for (const [state, rules] of Object.entries(grammar.states)) {\n    states[state] = rules.map((rule, i) => {\n      const where = `${grammar.name}.${state}[${i}]`;\n\n      if (rule.token && rule.groups) {\n        throw new Error(`${where}: a rule sets both token and groups; pick one`);\n      }\n      if (rule.embed && !rule.until) {\n        throw new Error(`${where}: embed needs until, or the region never ends`);\n      }\n      if (rule.push && rule.pop) {\n        throw new Error(`${where}: a rule cannot push and pop at once`);\n      }\n      if (rule.push && !grammar.states[rule.push]) {\n        throw new Error(`${where}: pushes state \"${rule.push}\", which does not exist`);\n      }\n\n      return {\n        ...rule,\n        match: sticky(rule.match),\n        until: rule.until ? sticky(rule.until) : undefined,\n      };\n    });\n  }\n\n  if (!grammar.tokenize && !states.root) {\n    throw new Error(`${grammar.name}: needs a root state or a tokenize override`);\n  }\n\n  return { ...grammar, states };\n}\n\nfunction sticky(re: RegExp): RegExp {\n  let flags = re.flags;\n  if (!flags.includes(\"y\")) flags += \"y\";\n  if (!flags.includes(\"d\")) flags += \"d\";\n  /* `g` and `y` together make lastIndex behave inconsistently across engines\n     for a pattern that can match empty — drop it, the scanner drives position\n     explicitly. */\n  flags = flags.replace(\"g\", \"\");\n  return new RegExp(re.source, flags);\n}\n\n/* --- The registry --------------------------------------------------------- */\n\nconst byName = new Map<string, Grammar>();\n\n/**\n * Registered explicitly from a VALUE import rather than by each language module\n * importing the registry for its side effect. `package.json` declares\n * `sideEffects: [\"*.css\"]`, which tells every bundler a bare `import \"./x\"` of\n * a `.ts` module is safe to delete — and esbuild does. That already cost this\n * project its entire icon set once (CAV-11); the registry that a table is\n * pushed INTO cannot be pruned while the table is reachable.\n */\nexport function registerGrammar(grammar: Grammar): void {\n  const names = [grammar.name, ...(grammar.aliases ?? [])];\n  for (const name of names) {\n    const key = name.toLowerCase();\n    const existing = byName.get(key);\n    if (existing && existing.name !== grammar.name) {\n      throw new Error(`language \"${name}\" is claimed by both ${existing.name} and ${grammar.name}`);\n    }\n    byName.set(key, grammar);\n  }\n}\n\n/**\n * Looks up a language by name or alias. Returns undefined for anything\n * unregistered — callers render it as plain text, because an unknown language\n * on a code block must never be an error. The block still has to be readable.\n */\nexport function getGrammar(language: string | null | undefined): Grammar | undefined {\n  if (!language) return undefined;\n  return byName.get(language.trim().toLowerCase());\n}\n\n/** The canonical name for an alias — `ts` becomes `typescript`. */\nexport function resolveLanguage(language: string | null | undefined): string | null {\n  return getGrammar(language)?.name ?? null;\n}\n\n/** Every registered language, canonical names only, sorted. Drives the picker. */\nexport function listLanguages(): string[] {\n  return [...new Set([...byName.values()].map((g) => g.name))].sort();\n}\n"],"names":["defineGrammar","grammar","states","state","rules","rule","i","where","sticky","re","flags","byName","registerGrammar","names","name","key","existing","getGrammar","language","resolveLanguage","listLanguages","g"],"mappings":"AAkBO,SAASA,EAAcC,GAA2B;AACvD,QAAMC,IAAiC,CAAA;AAEvC,aAAW,CAACC,GAAOC,CAAK,KAAK,OAAO,QAAQH,EAAQ,MAAM;AACxD,IAAAC,EAAOC,CAAK,IAAIC,EAAM,IAAI,CAACC,GAAMC,MAAM;AACrC,YAAMC,IAAQ,GAAGN,EAAQ,IAAI,IAAIE,CAAK,IAAIG,CAAC;AAE3C,UAAID,EAAK,SAASA,EAAK;AACrB,cAAM,IAAI,MAAM,GAAGE,CAAK,+CAA+C;AAEzE,UAAIF,EAAK,SAAS,CAACA,EAAK;AACtB,cAAM,IAAI,MAAM,GAAGE,CAAK,+CAA+C;AAEzE,UAAIF,EAAK,QAAQA,EAAK;AACpB,cAAM,IAAI,MAAM,GAAGE,CAAK,sCAAsC;AAEhE,UAAIF,EAAK,QAAQ,CAACJ,EAAQ,OAAOI,EAAK,IAAI;AACxC,cAAM,IAAI,MAAM,GAAGE,CAAK,mBAAmBF,EAAK,IAAI,yBAAyB;AAG/E,aAAO;AAAA,QACL,GAAGA;AAAA,QACH,OAAOG,EAAOH,EAAK,KAAK;AAAA,QACxB,OAAOA,EAAK,QAAQG,EAAOH,EAAK,KAAK,IAAI;AAAA,MAAA;AAAA,IAE7C,CAAC;AAGH,MAAI,CAACJ,EAAQ,YAAY,CAACC,EAAO;AAC/B,UAAM,IAAI,MAAM,GAAGD,EAAQ,IAAI,6CAA6C;AAG9E,SAAO,EAAE,GAAGA,GAAS,QAAAC,EAAA;AACvB;AAEA,SAASM,EAAOC,GAAoB;AAClC,MAAIC,IAAQD,EAAG;AACf,SAAKC,EAAM,SAAS,GAAG,MAAGA,KAAS,MAC9BA,EAAM,SAAS,GAAG,MAAGA,KAAS,MAInCA,IAAQA,EAAM,QAAQ,KAAK,EAAE,GACtB,IAAI,OAAOD,EAAG,QAAQC,CAAK;AACpC;AAIA,MAAMC,wBAAa,IAAA;AAUZ,SAASC,EAAgBX,GAAwB;AACtD,QAAMY,IAAQ,CAACZ,EAAQ,MAAM,GAAIA,EAAQ,WAAW,EAAG;AACvD,aAAWa,KAAQD,GAAO;AACxB,UAAME,IAAMD,EAAK,YAAA,GACXE,IAAWL,EAAO,IAAII,CAAG;AAC/B,QAAIC,KAAYA,EAAS,SAASf,EAAQ;AACxC,YAAM,IAAI,MAAM,aAAaa,CAAI,wBAAwBE,EAAS,IAAI,QAAQf,EAAQ,IAAI,EAAE;AAE9F,IAAAU,EAAO,IAAII,GAAKd,CAAO;AAAA,EACzB;AACF;AAOO,SAASgB,EAAWC,GAA0D;AACnF,MAAKA;AACL,WAAOP,EAAO,IAAIO,EAAS,KAAA,EAAO,aAAa;AACjD;AAGO,SAASC,EAAgBD,GAAoD;AAClF,SAAOD,EAAWC,CAAQ,GAAG,QAAQ;AACvC;AAGO,SAASE,IAA0B;AACxC,SAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAGT,EAAO,OAAA,CAAQ,EAAE,IAAI,CAACU,MAAMA,EAAE,IAAI,CAAC,CAAC,EAAE,KAAA;AAC/D;"}

package/dist/lib/syntax/tokenize.js

@@ -0,0 +1,96 @@
+import { getGrammar as k } from "./registry.js";
+const y = 12;
+function z(n, i) {
+  return $(n, k(i), 0, 0);
+}
+function $(n, i, t, e) {
+  if (!n) return [];
+  if (!i || e > y)
+    return [{ start: t, end: t + n.length, type: "text", lang: i?.name ?? "text" }];
+  if (i.tokenize) {
+    const o = {
+      sub: (c, r, s) => $(c, k(r), s, e + 1)
+    };
+    return f(i.tokenize(n, o), t);
+  }
+  return m(n, i, t, e);
+}
+function f(n, i) {
+  return i === 0 ? n : n.map((t) => ({ ...t, start: t.start + i, end: t.end + i }));
+}
+function m(n, i, t, e) {
+  const o = [], c = ["root"];
+  let r = 0, s = 0;
+  const a = () => {
+    r > s && x(o, t + s, t + r, "text", i.name), s = r;
+  };
+  for (; r < n.length; ) {
+    const d = c[c.length - 1], h = i.states[d] ?? [];
+    let l = !1;
+    for (let g = 0; g < h.length; g++) {
+      const u = h[g];
+      u.match.lastIndex = r;
+      const p = u.match.exec(n);
+      if (!(!p || p.index !== r)) {
+        if (p[0].length === 0)
+          throw new Error(`${i.name}.${d}[${g}] matched empty at ${r}`);
+        a(), w(o, p, u, t, i.name), r += p[0].length, u.embed ? r = v(n, p, u, o, i, t, e, r) : u.push ? c.push(u.push) : u.pop && c.length > 1 && c.pop(), s = r, l = !0;
+        break;
+      }
+    }
+    l || (r += 1);
+  }
+  return r = n.length, a(), o;
+}
+function v(n, i, t, e, o, c, r, s) {
+  const a = typeof t.embed == "function" ? t.embed(i) : t.embed, d = t.until, h = new RegExp(d.source, d.flags.replace("y", "") + "g");
+  h.lastIndex = s;
+  const l = h.exec(n), g = l ? l.index : n.length, u = n.slice(s, g);
+  if (u) {
+    const p = $(u, k(a), c + s, r + 1);
+    for (const b of p) e.push(b);
+  }
+  return l ? (x(e, c + l.index, c + l.index + l[0].length, t.untilToken ?? "punctuation", o.name), l.index + l[0].length) : n.length;
+}
+function w(n, i, t, e, o) {
+  const c = i.index, r = c + i[0].length;
+  if (t.token) {
+    x(n, e + c, e + r, t.token, o);
+    return;
+  }
+  if (t.groups) {
+    const s = i.indices;
+    let a = c;
+    for (let d = 0; d < t.groups.length; d++) {
+      const h = s?.[d + 1];
+      h && (h[0] > a && x(n, e + a, e + h[0], "text", o), x(n, e + h[0], e + h[1], t.groups[d] ?? "text", o), a = h[1]);
+    }
+    a < r && x(n, e + a, e + r, "text", o);
+    return;
+  }
+  x(n, e + c, e + r, "text", o);
+}
+function x(n, i, t, e, o) {
+  if (t <= i) return;
+  const c = n[n.length - 1];
+  if (c && c.end === i && c.type === e && c.lang === o) {
+    c.end = t;
+    return;
+  }
+  n.push({ start: i, end: t, type: e, lang: o });
+}
+function T(n, i) {
+  let t = 0;
+  for (const e of i) {
+    if (e.start !== t)
+      return e.start < t ? `token at ${e.start} overlaps the previous one, which ended at ${t}` : `gap in coverage from ${t} to ${e.start}`;
+    if (e.end <= e.start) return `empty or reversed token at ${e.start}`;
+    t = e.end;
+  }
+  return t !== n.length ? `coverage stops at ${t} of ${n.length}` : null;
+}
+export {
+  T as checkCoverage,
+  z as tokenize
+};
+//# sourceMappingURL=tokenize.js.map