markstream-solid 0.0.0-stage → 2.0.23

package/dist/client/mermaidWorkerClient-BAvGYsCO.js

@@ -0,0 +1,243 @@
+const z = () => import("mermaid"), E = "__MARKSTREAM_SOLID_MERMAID__";
+let l = null, d = !1, W = null, m = null, I = z;
+function _(e) {
+  const r = String(e?.securityLevel ?? "strict"), t = e?.flowchart?.htmlLabels;
+  return `${r}|htmlLabels:${t === !1 ? "0" : "1"}`;
+}
+function w(e) {
+  if (!e)
+    return e;
+  const r = e?.default ?? e;
+  if (r && (typeof r.render == "function" || typeof r.parse == "function" || typeof r.initialize == "function"))
+    return r;
+  if (r?.mermaidAPI && (typeof r.mermaidAPI.render == "function" || typeof r.mermaidAPI.parse == "function")) {
+    const t = r.mermaidAPI;
+    return {
+      ...r,
+      render: t.render.bind(t),
+      parse: t.parse ? t.parse.bind(t) : void 0,
+      initialize: (i) => typeof r.initialize == "function" ? r.initialize(i) : t.initialize ? t.initialize(i) : void 0
+    };
+  }
+  return e?.mermaid && typeof e.mermaid.render == "function" ? e.mermaid : r;
+}
+function b(e) {
+  if (e)
+    try {
+      const r = e?.initialize;
+      e.initialize = (t) => {
+        const i = { suppressErrorRendering: !0, ...t || {} };
+        if (typeof r == "function")
+          return r.call(e, i);
+        if (e?.mermaidAPI && typeof e.mermaidAPI.initialize == "function")
+          return e.mermaidAPI.initialize(i);
+      };
+    } catch {
+    }
+}
+function k(e, r) {
+  if (!e || !r)
+    return;
+  const t = _(r);
+  if (W !== t)
+    try {
+      typeof e.initialize == "function" ? e.initialize(r) : e.mermaidAPI?.initialize && e.mermaidAPI.initialize(r), W = t;
+    } catch {
+    }
+}
+function D() {
+  try {
+    const e = globalThis;
+    return w(e?.[E] ?? e?.mermaid);
+  } catch {
+    return null;
+  }
+}
+function g(e) {
+  try {
+    globalThis[E] = e;
+  } catch {
+  }
+}
+function L() {
+  l = null, d = !1, W = null, m = null;
+  try {
+    delete globalThis[E];
+  } catch {
+  }
+}
+function A(e) {
+  I = e, L();
+}
+function K(e) {
+  A(e ?? z);
+}
+function v() {
+  A(null);
+}
+function j() {
+  return typeof I == "function";
+}
+async function x(e) {
+  if (l)
+    return k(l, e), l;
+  const r = D();
+  if (r)
+    return b(r), l = r, g(l), k(l, e), l;
+  if (m) {
+    const i = await m;
+    return i && k(i, e), i;
+  }
+  if (d)
+    return null;
+  const t = I;
+  if (!t)
+    return d = !0, null;
+  m = (async () => {
+    try {
+      const i = await t(), o = w(i);
+      return o ? (b(o), l = o, g(l), l) : (d = !0, null);
+    } catch {
+      return d = !0, null;
+    }
+  })();
+  try {
+    const i = await m;
+    return i && k(i, e), i;
+  } finally {
+    m = null;
+  }
+}
+let a = null, u = null;
+const n = /* @__PURE__ */ new Map();
+let y = 5, P = !1;
+function B(e) {
+  P = !!e;
+}
+function U(e) {
+  Number.isFinite(e) && e > 0 && (y = Math.floor(e));
+}
+function F() {
+  return { inFlight: n.size, max: y };
+}
+const O = "WORKER_BUSY", T = "MERMAID_DISABLED";
+function G(e) {
+  a = e, u = null;
+  const r = e;
+  a.onmessage = (t) => {
+    if (a !== r)
+      return;
+    const { id: i, ok: o, result: M, error: c } = t.data || {}, f = n.get(i);
+    f && (o === !1 || c ? f.reject(new Error(c || "Unknown error")) : f.resolve(M));
+  }, a.onerror = (t) => {
+    if (a === r) {
+      if (n.size === 0) {
+        console.debug?.("[markstream-solid:mermaidWorkerClient] Worker error (idle):", t?.message || t);
+        return;
+      }
+      try {
+        P ? console.error("[markstream-solid:mermaidWorkerClient] Worker error:", t?.message || t) : console.debug?.("[markstream-solid:mermaidWorkerClient] Worker error:", t?.message || t);
+      } catch {
+      }
+      for (const [, i] of n.entries())
+        i.reject(new Error(`Worker error: ${t.message}`));
+      n.clear();
+    }
+  }, a.onmessageerror = (t) => {
+    if (a === r) {
+      if (n.size === 0) {
+        console.debug?.("[markstream-solid:mermaidWorkerClient] Worker messageerror (idle):", t);
+        return;
+      }
+      for (const [, i] of n.entries())
+        i.reject(new Error("Worker messageerror"));
+      n.clear();
+    }
+  };
+}
+function N() {
+  if (a)
+    try {
+      for (const [, e] of n.entries())
+        e.reject(new Error("Worker cleared"));
+      n.clear(), a.terminate?.();
+    } catch {
+    }
+  a = null, u = null;
+}
+function C() {
+  return a || (u = new Error("[markstream-solid:mermaidWorkerClient] No worker instance set. Please inject a Worker via setMermaidWorker()."), u.name = "WorkerInitError", u.code = "WORKER_INIT_ERROR", null);
+}
+function R(e, r, t = 1400) {
+  if (!j()) {
+    const o = new Error("Mermaid rendering disabled");
+    return o.name = "MermaidDisabled", o.code = T, Promise.reject(o);
+  }
+  if (u)
+    return Promise.reject(u);
+  const i = C();
+  if (!i)
+    return Promise.reject(u);
+  if (n.size >= y) {
+    const o = new Error("Worker busy");
+    return o.name = "WorkerBusy", o.code = O, o.inFlight = n.size, o.max = y, Promise.reject(o);
+  }
+  return new Promise((o, M) => {
+    const c = Math.random().toString(36).slice(2);
+    let f = !1, p = null;
+    const h = () => {
+      f || (f = !0, p != null && clearTimeout(p), n.delete(c));
+    };
+    n.set(c, {
+      resolve: (s) => {
+        h(), o(s);
+      },
+      reject: (s) => {
+        h(), M(s);
+      }
+    });
+    try {
+      i.postMessage({ id: c, action: e, payload: r });
+    } catch (s) {
+      n.delete(c), M(s);
+      return;
+    }
+    p = setTimeout(() => {
+      const s = new Error("Worker call timed out");
+      s.name = "WorkerTimeout", s.code = "WORKER_TIMEOUT", n.get(c)?.reject(s);
+    }, t);
+  });
+}
+async function Y(e, r, t = 1400) {
+  return await R("canParse", { code: e, theme: r }, t);
+}
+async function $(e, r, t = 1400) {
+  return await R("findPrefix", { code: e, theme: r }, t);
+}
+function q() {
+  if (a)
+    try {
+      for (const [, e] of n.entries())
+        e.reject(new Error("Worker terminated"));
+      n.clear(), a.terminate();
+    } finally {
+      a = null;
+    }
+}
+export {
+  T as M,
+  O as a,
+  N as b,
+  Y as c,
+  v as d,
+  K as e,
+  $ as f,
+  x as g,
+  F as h,
+  j as i,
+  G as j,
+  B as k,
+  U as l,
+  A as s,
+  q as t
+};

package/dist/client/utils/index.js

@@ -0,0 +1,31 @@
+import { N as o, g as r, a as s, i as n, l as t, d as g, n as i, p as l, e as m, r as d, h as f, s as c, j as u, u as R } from "../languageIcon-CDTPjsAQ.js";
+import { defaultRByClass as I, estimateRByFormula as L, recommendNForSamples as M, recommendWorkerThreshold as h } from "./katex-threshold.js";
+import { disablePerfMonitoring as C, enablePerfMonitoring as E, getPerfReport as T, perfMonitor as k } from "./performance-monitor.js";
+import { safeCancelRaf as B, safeRaf as N } from "./safeRaf.js";
+export * from "stream-markdown-parser";
+export {
+  o as MARKSTREAM_NODE_LIFECYCLE_KEY,
+  I as defaultRByClass,
+  C as disablePerfMonitoring,
+  E as enablePerfMonitoring,
+  L as estimateRByFormula,
+  r as getLanguageIcon,
+  T as getPerfReport,
+  s as getRegisteredThemes,
+  n as isCodeBlockRuntimeReady,
+  t as languageIconsRevision,
+  g as languageMap,
+  i as normalizeLanguageIdentifier,
+  k as perfMonitor,
+  l as preloadCodeBlockRuntime,
+  m as preloadExtendedLanguageIcons,
+  M as recommendNForSamples,
+  h as recommendWorkerThreshold,
+  d as registerIconTheme,
+  f as resolveLanguageId,
+  B as safeCancelRaf,
+  N as safeRaf,
+  c as setIconTheme,
+  u as setLanguageIconResolver,
+  R as useMarkstreamNodeLifecycle
+};

package/dist/client/utils/katex-threshold.js

@@ -0,0 +1,32 @@
+function s({ R: e, H: t = 0, B: n = 50 }) {
+  const r = e * (1 - t) || 1e-6;
+  return Math.max(1, Math.floor(n / r));
+}
+function m(e) {
+  const t = e.length, n = (e.match(/\\/g) || []).length, r = t + n * 10;
+  return r < 10 ? "simple" : r < 40 ? "medium" : "complex";
+}
+function u(e) {
+  switch (e) {
+    case "simple":
+      return 3;
+    case "medium":
+      return 10;
+    case "complex":
+      return 30;
+  }
+}
+function l(e, t) {
+  let n = 0;
+  for (const r of e) {
+    const o = m(r), c = u(o);
+    c > n && (n = c);
+  }
+  return s({ R: n, H: t?.H ?? 0, B: t?.B ?? 50 });
+}
+export {
+  u as defaultRByClass,
+  m as estimateRByFormula,
+  l as recommendNForSamples,
+  s as recommendWorkerThreshold
+};

package/dist/client/utils/performance-monitor.js

@@ -0,0 +1,73 @@
+class v {
+  metrics = [];
+  enabled = !1;
+  maxMetrics = 1e3;
+  // Prevent memory leak
+  enable() {
+    this.enabled = !0;
+  }
+  disable() {
+    this.enabled = !1;
+  }
+  recordRender(e) {
+    this.enabled && (this.metrics.push(e), this.metrics.length > this.maxMetrics && this.metrics.shift());
+  }
+  getStats() {
+    if (this.metrics.length === 0)
+      return {
+        totalRenders: 0,
+        cacheHitRate: 0,
+        averageWorkerTime: 0,
+        averageDirectTime: 0,
+        averageCacheHitTime: 0,
+        workerSavings: 0,
+        recommendation: "Insufficient data"
+      };
+    const e = this.metrics.filter((t) => t.type === "worker" && t.success), o = this.metrics.filter((t) => t.type === "direct" && t.success), n = this.metrics.filter((t) => t.type === "cache-hit"), c = this.metrics.length, d = n.length, l = d / c * 100, g = e.length > 0 ? e.reduce((t, r) => t + r.duration, 0) / e.length : 0, s = o.length > 0 ? o.reduce((t, r) => t + r.duration, 0) / o.length : 0, h = n.length > 0 ? n.reduce((t, r) => t + r.duration, 0) / n.length : 0, m = c * s, f = e.reduce((t, r) => t + r.duration, 0) + o.reduce((t, r) => t + r.duration, 0) + n.reduce((t, r) => t + r.duration, 0), u = m - f;
+    let i = "";
+    return l > 70 && g < s * 2 ? i = "✅ Worker + Cache is highly beneficial" : l > 50 ? i = "✅ Worker + Cache is beneficial" : g > s * 3 ? i = "⚠️ Worker overhead too high, consider direct rendering" : s < 5 ? i = "⚠️ Formulas too simple, Worker overhead may not be worth it" : i = "✅ Worker prevents main thread blocking", {
+      totalRenders: c,
+      cacheHits: d,
+      cacheHitRate: l.toFixed(1),
+      workerCalls: e.length,
+      directCalls: o.length,
+      averageWorkerTime: g.toFixed(2),
+      averageDirectTime: s.toFixed(2),
+      averageCacheHitTime: h.toFixed(3),
+      workerSavings: u.toFixed(2),
+      recommendation: i
+    };
+  }
+  printReport() {
+    const e = this.getStats();
+    return console.group("📊 KaTeX Rendering Performance Report"), console.log(`Total renders: ${e.totalRenders}`), console.log(`Cache hits: ${e.cacheHits} (${e.cacheHitRate}%)`), console.log(`Worker calls: ${e.workerCalls}`), console.log(`Direct calls: ${e.directCalls}`), console.log(""), console.log("Timing:"), console.log(`  Worker average: ${e.averageWorkerTime}ms`), console.log(`  Direct average: ${e.averageDirectTime}ms`), console.log(`  Cache hit average: ${e.averageCacheHitTime}ms`), console.log(""), console.log(`Time saved: ${e.workerSavings}ms`), console.log(`Recommendation: ${e.recommendation}`), console.groupEnd(), e;
+  }
+  reset() {
+    this.metrics = [];
+  }
+  // Export metrics for analysis
+  exportMetrics() {
+    return {
+      metrics: [...this.metrics],
+      stats: this.getStats(),
+      timestamp: Date.now()
+    };
+  }
+}
+const a = new v();
+function T() {
+  a.enable(), console.log("📊 KaTeX performance monitoring enabled");
+}
+function w() {
+  a.disable(), console.log("📊 KaTeX performance monitoring disabled");
+}
+function k() {
+  return a.printReport();
+}
+typeof window < "u" && (window.__katexPerfReport = k, window.__katexPerfMonitor = a);
+export {
+  w as disablePerfMonitoring,
+  T as enablePerfMonitoring,
+  k as getPerfReport,
+  a as perfMonitor
+};

package/dist/client/utils/safeRaf.js

@@ -0,0 +1,27 @@
+function n(e) {
+  try {
+    if (typeof globalThis < "u" && typeof globalThis.requestAnimationFrame == "function")
+      return globalThis.requestAnimationFrame(e);
+  } catch {
+  }
+  return globalThis.setTimeout(e, 0);
+}
+function t(e) {
+  try {
+    if (e == null)
+      return;
+    if (typeof globalThis < "u" && typeof globalThis.cancelAnimationFrame == "function") {
+      globalThis.cancelAnimationFrame(e);
+      return;
+    }
+  } catch {
+  }
+  try {
+    globalThis.clearTimeout(e);
+  } catch {
+  }
+}
+export {
+  t as safeCancelRaf,
+  n as safeRaf
+};

package/dist/client/workers/katexCdnWorker.js

@@ -0,0 +1,177 @@
+function s(e) {
+  return JSON.stringify(e);
+}
+function i(e) {
+  const t = e.mode ?? "classic", n = {
+    throwOnError: !0,
+    displayMode: !0,
+    output: "html",
+    strict: "ignore",
+    ...e.renderOptions || {}
+  }, r = s(n), o = s(e.katexUrl), a = e.mhchemUrl ? s(e.mhchemUrl) : '""';
+  return t === "module" ? `
+let DEBUG = false
+let katex = null
+let katexLoadError = null
+let loadPromise = null
+
+function normalizeKaTeX(mod) {
+  const resolved = mod && mod.default ? mod.default : mod
+  if (resolved && typeof resolved.renderToString === 'function')
+    return resolved
+  return null
+}
+
+async function loadKaTeX() {
+  if (katex || katexLoadError)
+    return
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      try {
+        const mod = await import(${o})
+        katex = normalizeKaTeX(mod) || null
+        const mhchemUrl = ${a}
+        if (mhchemUrl) {
+          try {
+            await import(mhchemUrl)
+          }
+          catch (e) {
+            if (DEBUG)
+              console.warn('[markstream-solid:katex-cdn-worker] failed to load mhchem', e)
+          }
+        }
+      }
+      catch (e) {
+        katexLoadError = e
+      }
+    })()
+  }
+  await loadPromise
+}
+
+globalThis.addEventListener('message', async (ev) => {
+  const data = ev.data || {}
+  if (data.type === 'init') {
+    DEBUG = !!data.debug
+    return
+  }
+
+  const id = data.id ?? ''
+  const content = data.content ?? ''
+  const displayMode = data.displayMode ?? true
+
+  await loadKaTeX()
+
+  if (!katex) {
+    const reason = katexLoadError ? String(katexLoadError?.message || katexLoadError) : 'KaTeX is not available in worker'
+    globalThis.postMessage({ id, error: reason, content, displayMode })
+    return
+  }
+
+  try {
+    const opts = ${r}
+    const html = katex.renderToString(content, { ...opts, displayMode: !!displayMode })
+    globalThis.postMessage({ id, html, content, displayMode })
+  }
+  catch (err) {
+    globalThis.postMessage({ id, error: String(err?.message || err), content, displayMode })
+  }
+})
+`.trimStart() : `
+let DEBUG = false
+let katex = null
+let katexLoadError = null
+
+function normalizeKaTeX(val) {
+  const resolved = val && val.default ? val.default : val
+  if (resolved && typeof resolved.renderToString === 'function')
+    return resolved
+  return null
+}
+
+function loadKaTeXClassic() {
+  if (katex || katexLoadError)
+    return
+  try {
+    importScripts(${o})
+    const mhchemUrl = ${a}
+    if (mhchemUrl) {
+      try {
+        importScripts(mhchemUrl)
+      }
+      catch (e) {
+        if (DEBUG)
+          console.warn('[markstream-solid:katex-cdn-worker] failed to load mhchem', e)
+      }
+    }
+    katex = normalizeKaTeX(globalThis.katex)
+  }
+  catch (e) {
+    katexLoadError = e
+  }
+}
+
+loadKaTeXClassic()
+
+globalThis.addEventListener('message', (ev) => {
+  const data = ev.data || {}
+  if (data.type === 'init') {
+    DEBUG = !!data.debug
+    return
+  }
+
+  const id = data.id ?? ''
+  const content = data.content ?? ''
+  const displayMode = data.displayMode ?? true
+
+  if (!katex && !katexLoadError)
+    loadKaTeXClassic()
+
+  if (!katex) {
+    const reason = katexLoadError ? String(katexLoadError?.message || katexLoadError) : 'KaTeX is not available in worker'
+    globalThis.postMessage({ id, error: reason, content, displayMode })
+    return
+  }
+
+  try {
+    const opts = ${r}
+    const html = katex.renderToString(content, { ...opts, displayMode: !!displayMode })
+    globalThis.postMessage({ id, html, content, displayMode })
+  }
+  catch (err) {
+    globalThis.postMessage({ id, error: String(err?.message || err), content, displayMode })
+  }
+})
+`.trimStart();
+}
+function m(e) {
+  const t = i(e);
+  if (typeof Worker > "u" || typeof URL > "u" || typeof Blob > "u")
+    return {
+      worker: null,
+      dispose: () => {
+      },
+      source: t
+    };
+  const n = new Blob([t], { type: "text/javascript" }), r = URL.createObjectURL(n);
+  let o = !1;
+  const a = () => {
+    if (!o) {
+      o = !0;
+      try {
+        URL.revokeObjectURL(r);
+      } catch {
+      }
+    }
+  }, l = (e.mode ?? "classic") === "module" ? { ...e.workerOptions ?? {}, type: "module" } : e.workerOptions, d = new Worker(r, l);
+  if (e.debug)
+    try {
+      d.postMessage({ type: "init", debug: !0 });
+    } catch {
+    }
+  return { worker: d, dispose: a, source: t };
+}
+export {
+  i as buildKaTeXCDNWorkerSource,
+  m as createKaTeXWorkerFromCDN
+};

package/dist/client/workers/katexRenderer.worker.js

@@ -0,0 +1,45 @@
+import d from "katex";
+import "katex/dist/contrib/mhchem";
+let i = !1;
+globalThis.addEventListener("message", (r) => {
+  const e = r.data || {};
+  if (e.type === "init") {
+    i = !!e.debug;
+    return;
+  }
+  const a = e.id ?? "", t = e.content ?? "", o = e.displayMode ?? !0;
+  try {
+    i && console.debug("[markstream-solid:katexRenderer.worker] render start", { id: a, displayMode: o, content: t });
+    const s = d.renderToString(t, {
+      throwOnError: !0,
+      displayMode: o,
+      output: "html",
+      strict: "ignore"
+    }), n = {
+      id: a,
+      html: s,
+      content: t,
+      displayMode: o
+    };
+    globalThis.postMessage(n);
+  } catch (s) {
+    const n = {
+      id: a,
+      error: String(s?.message ?? s),
+      content: t,
+      displayMode: o
+    };
+    globalThis.postMessage(n);
+  }
+});
+globalThis.addEventListener("error", (r) => {
+  try {
+    globalThis.postMessage({
+      id: "__worker_uncaught__",
+      error: String(r.message ?? r.error),
+      content: "",
+      displayMode: !0
+    });
+  } catch {
+  }
+});

package/dist/client/workers/katexWorkerClient.js

@@ -0,0 +1,16 @@
+import { W as r, c as s, g as o, a as t, i as K, r as k, h as T, s as X, j as W, k as c, l as u, m as l, w as n } from "../katexWorkerClient-ZLzkPVv_.js";
+export {
+  r as WORKER_BUSY_CODE,
+  s as clearKaTeXWorker,
+  o as getKaTeXBackpressureDefaults,
+  t as getKaTeXWorkerLoad,
+  K as isKaTeXWorkerBusy,
+  k as renderKaTeXInWorker,
+  T as renderKaTeXWithBackpressure,
+  X as setKaTeXBackpressureDefaults,
+  W as setKaTeXCache,
+  c as setKaTeXWorker,
+  u as setKaTeXWorkerDebug,
+  l as setKaTeXWorkerMaxConcurrency,
+  n as waitForKaTeXWorkerSlot
+};