@oml/markdown 0.14.17 → 0.16.0

package/out/static/browser-runtime.bundle.js

@@ -4166,8 +4166,8 @@
     }
     return lineValue;
   }
-  function garbageCollect(caches, length2) {
-    each(caches, (cache5) => {
+  function garbageCollect(caches2, length2) {
+    each(caches2, (cache5) => {
       const gc = cache5.gc;
       const gcLen = gc.length / 2;
       let i;
@@ -9489,7 +9489,7 @@
           return labelSizes;
         }
         _computeLabelSizes(ticks, length2, maxTicksLimit) {
-          const { ctx, _longestTextCache: caches } = this;
+          const { ctx, _longestTextCache: caches2 } = this;
           const widths = [];
           const heights = [];
           const increment = Math.floor(length2 / getTicksLimit(length2, maxTicksLimit));
@@ -9500,7 +9500,7 @@
             label = ticks[i].label;
             tickFont = this._resolveTickFontOptions(i);
             ctx.font = fontString = tickFont.string;
-            cache5 = caches[fontString] = caches[fontString] || {
+            cache5 = caches2[fontString] = caches2[fontString] || {
               data: {},
               gc: []
             };
@@ -9523,7 +9523,7 @@
             widestLabelSize = Math.max(width2, widestLabelSize);
             highestLabelSize = Math.max(height2, highestLabelSize);
           }
-          garbageCollect(caches, length2);
+          garbageCollect(caches2, length2);
           const widest = widths.indexOf(widestLabelSize);
           const highest = heights.indexOf(highestLabelSize);
           const valueAt = (idx) => ({
@@ -28245,18 +28245,18 @@
       return [text4, ""];
     }
     const length2 = text4.length;
-    const caches = {};
+    const caches2 = {};
     let index3 = Math.round(splitWidth / totalWidth * length2 - 1);
     if (index3 < 0) {
       index3 = 0;
     }
     while (index3 >= 0 && index3 < length2) {
       const frontText = text4.slice(0, index3);
-      const frontWidth = caches[frontText] || measureText(frontText, style2).width;
+      const frontWidth = caches2[frontText] || measureText(frontText, style2).width;
       const behindText = text4.slice(0, index3 + 1);
-      const behindWidth = caches[behindText] || measureText(behindText, style2).width;
-      caches[frontText] = frontWidth;
-      caches[behindText] = behindWidth;
+      const behindWidth = caches2[behindText] || measureText(behindText, style2).width;
+      caches2[frontText] = frontWidth;
+      caches2[behindText] = behindWidth;
       if (frontWidth > splitWidth) {
         index3 -= 1;
       } else if (behindWidth <= splitWidth) {
@@ -73679,6 +73679,13 @@ ${serialized}`;
   };
 
   // src/renderers/table-renderer.ts
+  function buildTableUiStateKey(blockId) {
+    if (typeof blockId !== "string" || blockId.length === 0) {
+      return void 0;
+    }
+    const pageKey = `${window.location.origin}${window.location.pathname}`;
+    return `${pageKey}::${blockId}`;
+  }
   var TableMarkdownBlockRenderer = class extends QueryMarkdownBlockRenderer {
     constructor() {
       super(...arguments);
@@ -73760,7 +73767,8 @@ ${serialized}`;
       const columnContexts = createColumnContexts(visibleColumns, visibleRows);
       const treeModel = isTree ? this.createTreeModel(columns, allRowsWithIndex, visibleColumnIndexes, options) : void 0;
       const fullyExpandedTreeRows = isTree && treeModel ? this.flattenAllTreeRows(treeModel) : void 0;
-      const persistedState = blockId ? window.__omlGetPersistedTableUiState?.(blockId) : void 0;
+      const tableUiStateKey = buildTableUiStateKey(blockId);
+      const persistedState = tableUiStateKey ? window.__omlGetPersistedTableUiState?.(tableUiStateKey) : void 0;
       const state = {
         search: persistedState?.search ?? "",
         pageSize: persistedState?.pageSize ?? 50,
@@ -73773,10 +73781,10 @@ ${serialized}`;
         expanded: new Set(treeModel?.expandableNodes ?? [])
       };
       const persistUiState = () => {
-        if (!blockId) {
+        if (!tableUiStateKey) {
           return;
         }
-        window.__omlSetPersistedTableUiState?.(blockId, {
+        window.__omlSetPersistedTableUiState?.(tableUiStateKey, {
           search: state.search,
           pageSize: state.pageSize,
           page: state.page,
@@ -76014,7 +76022,703 @@ ${serialized}`;
     }
   }
   setupDownloadHandler();
-  void applyExecutionResults();
+  function ensureInitialContentLoaded() {
+    const content9 = document.getElementById("oml-md-content");
+    if (!content9) {
+      return;
+    }
+    if (content9.childNodes.length > 0) {
+      return;
+    }
+    const template = document.getElementById("oml-md-initial-content");
+    if (!(template instanceof HTMLTemplateElement)) {
+      return;
+    }
+    content9.innerHTML = template.innerHTML;
+  }
+  async function bootstrapStaticRender() {
+    void pruneOldRuntimeCaches();
+    const body = document.body;
+    const previousBodyVisibility = body.style.visibility;
+    body.style.visibility = "hidden";
+    ensureInitialContentLoaded();
+    try {
+      await applyExecutionResults();
+      await Promise.all([
+        applyJsBlocks(),
+        applyPyBlocks(),
+        applyRBlocks()
+      ]);
+    } finally {
+      document.documentElement.classList.remove("oml-md-booting");
+      document.body.classList.remove("oml-md-booting");
+      body.style.visibility = previousBodyVisibility || "visible";
+    }
+  }
+  function getScriptSparqlCache() {
+    return parseJsonNode("oml-md-script-sparql-cache", {});
+  }
+  var PYTHON_PANEL_CACHE_STORAGE_KEY = "oml-md-python-panel-cache-v1";
+  var R_PANEL_CACHE_STORAGE_KEY = "oml-md-r-panel-cache-v1";
+  var JS_PANEL_CACHE_STORAGE_KEY = "oml-md-js-panel-cache-v1";
+  var MAX_PYTHON_PANEL_CACHE_ENTRIES = 64;
+  var MAX_R_PANEL_CACHE_ENTRIES = 64;
+  var MAX_JS_PANEL_CACHE_ENTRIES = 64;
+  var pythonPanelHtmlCache = readPythonPanelCache();
+  var rPanelHtmlCache = readRPanelCache();
+  var jsPanelHtmlCache = readJsPanelCache();
+  function readPythonPanelCache() {
+    try {
+      const raw2 = window.localStorage.getItem(PYTHON_PANEL_CACHE_STORAGE_KEY);
+      const parsed = raw2 ? JSON.parse(raw2) : {};
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {};
+      }
+      const cache5 = {};
+      for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value === "string") {
+          cache5[key] = value;
+        }
+      }
+      return cache5;
+    } catch {
+      return {};
+    }
+  }
+  function rememberPythonPanelCache(key, html2) {
+    const nextEntries = Object.entries(pythonPanelHtmlCache).filter(([entryKey]) => entryKey !== key);
+    nextEntries.push([key, html2]);
+    while (nextEntries.length > MAX_PYTHON_PANEL_CACHE_ENTRIES) {
+      nextEntries.shift();
+    }
+    pythonPanelHtmlCache = Object.fromEntries(nextEntries);
+    try {
+      window.localStorage.setItem(PYTHON_PANEL_CACHE_STORAGE_KEY, JSON.stringify(pythonPanelHtmlCache));
+    } catch {
+    }
+  }
+  function readRPanelCache() {
+    try {
+      const raw2 = window.localStorage.getItem(R_PANEL_CACHE_STORAGE_KEY);
+      const parsed = raw2 ? JSON.parse(raw2) : {};
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {};
+      }
+      const cache5 = {};
+      for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value === "string") {
+          cache5[key] = value;
+        }
+      }
+      return cache5;
+    } catch {
+      return {};
+    }
+  }
+  function rememberRPanelCache(key, html2) {
+    const nextEntries = Object.entries(rPanelHtmlCache).filter(([entryKey]) => entryKey !== key);
+    nextEntries.push([key, html2]);
+    while (nextEntries.length > MAX_R_PANEL_CACHE_ENTRIES) {
+      nextEntries.shift();
+    }
+    rPanelHtmlCache = Object.fromEntries(nextEntries);
+    try {
+      window.localStorage.setItem(R_PANEL_CACHE_STORAGE_KEY, JSON.stringify(rPanelHtmlCache));
+    } catch {
+    }
+  }
+  function readJsPanelCache() {
+    try {
+      const raw2 = window.localStorage.getItem(JS_PANEL_CACHE_STORAGE_KEY);
+      const parsed = raw2 ? JSON.parse(raw2) : {};
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {};
+      }
+      const cache5 = {};
+      for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value === "string") {
+          cache5[key] = value;
+        }
+      }
+      return cache5;
+    } catch {
+      return {};
+    }
+  }
+  function rememberJsPanelCache(key, html2) {
+    const nextEntries = Object.entries(jsPanelHtmlCache).filter(([entryKey]) => entryKey !== key);
+    nextEntries.push([key, html2]);
+    while (nextEntries.length > MAX_JS_PANEL_CACHE_ENTRIES) {
+      nextEntries.shift();
+    }
+    jsPanelHtmlCache = Object.fromEntries(nextEntries);
+    try {
+      window.localStorage.setItem(JS_PANEL_CACHE_STORAGE_KEY, JSON.stringify(jsPanelHtmlCache));
+    } catch {
+    }
+  }
+  function buildPythonPanelCacheKey(blockId, source, blockCache) {
+    const page = `${window.location.origin}${window.location.pathname}${window.location.search}`;
+    return `python|${page}|${blockId}|${hash32(source)}|${hash32(JSON.stringify(blockCache))}`;
+  }
+  function buildRPanelCacheKey(blockId, source, blockCache) {
+    const page = `${window.location.origin}${window.location.pathname}${window.location.search}`;
+    return `r|${page}|${blockId}|${hash32(source)}|${hash32(JSON.stringify(blockCache))}`;
+  }
+  function buildJsPanelCacheKey(blockId, source, blockCache) {
+    const page = `${window.location.origin}${window.location.pathname}${window.location.search}`;
+    return `js|${page}|${blockId}|${hash32(source)}|${hash32(JSON.stringify(blockCache))}`;
+  }
+  function hash32(input) {
+    let hash = 2166136261;
+    for (let i = 0; i < input.length; i++) {
+      hash ^= input.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16);
+  }
+  function sparqlResultToHtmlTable(result) {
+    if (!result.success || result.rows.length === 0) {
+      const msg = result.error ?? "No results";
+      return result.error ? `<p class="oml-md-js-error">${msg}</p>` : `<p class="oml-md-js-empty">No results</p>`;
+    }
+    const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const header = result.columns.map((c) => `<th>${esc(c)}</th>`).join("");
+    const body = result.rows.map(
+      (row) => `<tr>${result.columns.map((c) => `<td>${esc(row[c] ?? "")}</td>`).join("")}</tr>`
+    ).join("");
+    return `<div class="oml-md-table-wrapper"><table class="oml-md-table"><thead><tr>${header}</tr></thead><tbody>${body}</tbody></table></div>`;
+  }
+  function makeScriptPanel() {
+    const panel = document.createElement("div");
+    panel.className = "oml-md-js-result";
+    return panel;
+  }
+  function appendResult(panel, result) {
+    if (result.error) {
+      const el = document.createElement("div");
+      el.className = "oml-md-js-error";
+      el.textContent = result.error;
+      panel.appendChild(el);
+    }
+    if (panel.childElementCount === 0) {
+      const el = document.createElement("div");
+      el.className = "oml-md-js-empty";
+      el.textContent = "(no output)";
+      panel.appendChild(el);
+    }
+  }
+  var loadedScripts = /* @__PURE__ */ new Set();
+  async function loadScript(url) {
+    if (loadedScripts.has(url)) {
+      return;
+    }
+    await new Promise((resolve4, reject) => {
+      const script = document.createElement("script");
+      script.src = url;
+      script.onload = () => {
+        loadedScripts.add(url);
+        resolve4();
+      };
+      script.onerror = () => reject(new Error(`Failed to load script: ${url}`));
+      document.head.appendChild(script);
+    });
+  }
+  function isPyodideNoise(text4) {
+    return /^(Loading|Loaded|Unloading) /.test(text4) || text4.includes("already loaded from") || text4.includes("channel");
+  }
+  async function executeJsCode(code2, blockCache, container) {
+    let statusEl = document.createElement("div");
+    statusEl.className = "oml-md-js-text-output";
+    statusEl.textContent = "Running JavaScript block\u2026";
+    container.appendChild(statusEl);
+    const clearStatus = () => {
+      if (statusEl?.parentElement === container) {
+        container.removeChild(statusEl);
+      }
+      statusEl = void 0;
+    };
+    const appendHtml = (html2) => {
+      clearStatus();
+      const el = document.createElement("div");
+      el.className = "oml-md-js-html-output";
+      el.style.color = window.getComputedStyle(document.body).color;
+      el.innerHTML = html2;
+      container.appendChild(el);
+    };
+    const appendText = (text4) => {
+      clearStatus();
+      const pre = document.createElement("pre");
+      pre.className = "oml-md-js-text-output";
+      pre.textContent = text4;
+      container.appendChild(pre);
+    };
+    const display = (content9) => {
+      if (typeof content9 === "string") {
+        appendHtml(content9);
+      } else {
+        appendText(String(content9));
+      }
+    };
+    const query = async (sparql) => {
+      return blockCache[sparql] ?? { success: false, columns: [], rows: [], error: "SPARQL not pre-fetched for this query" };
+    };
+    const table2 = (result) => sparqlResultToHtmlTable(result);
+    const load = async (url) => loadScript(url);
+    const savedLog = console.log;
+    const savedWarn = console.warn;
+    const savedError = console.error;
+    console.log = (...args) => {
+      const text4 = args.map((v2) => typeof v2 === "string" ? v2 : JSON.stringify(v2, null, 2)).join(" ");
+      if (!isPyodideNoise(text4)) {
+        appendText(text4);
+      }
+    };
+    console.warn = console.log;
+    console.error = (...args) => {
+      const text4 = "[error] " + args.map((v2) => typeof v2 === "string" ? v2 : JSON.stringify(v2, null, 2)).join(" ");
+      if (!isPyodideNoise(text4)) {
+        appendText(text4);
+      }
+    };
+    try {
+      const AsyncFunction = Object.getPrototypeOf(async function() {
+      }).constructor;
+      const fn = new AsyncFunction("display", "query", "table", "load", code2);
+      await fn(display, query, table2, load);
+      clearStatus();
+      return {};
+    } catch (error2) {
+      clearStatus();
+      return { error: error2 instanceof Error ? `${error2.name}: ${error2.message}` : String(error2) };
+    } finally {
+      console.log = savedLog;
+      console.warn = savedWarn;
+      console.error = savedError;
+    }
+  }
+  async function applyJsBlocks() {
+    const cache5 = getScriptSparqlCache();
+    const codeNodes = Array.from(document.querySelectorAll("pre > code.language-javascript, pre > code.language-js"));
+    const sourceBlocks = codeNodes.map((code2) => code2.parentElement).filter((pre) => pre instanceof HTMLElement);
+    for (const pre of sourceBlocks) {
+      pre.style.visibility = "hidden";
+    }
+    try {
+      for (const code2 of codeNodes) {
+        const pre = code2.parentElement;
+        const blockId = pre.dataset.omlBlockId ?? "";
+        const blockCache = cache5[blockId] ?? {};
+        const source = code2.textContent ?? "";
+        const cacheKey = buildJsPanelCacheKey(blockId, source, blockCache);
+        const cachedHtml = jsPanelHtmlCache[cacheKey];
+        if (typeof cachedHtml === "string") {
+          const panel2 = makeScriptPanel();
+          panel2.innerHTML = cachedHtml;
+          pre.replaceWith(panel2);
+          continue;
+        }
+        const panel = makeScriptPanel();
+        pre.replaceWith(panel);
+        const result = await executeJsCode(source, blockCache, panel);
+        appendResult(panel, result);
+        if (!result.error) {
+          rememberJsPanelCache(cacheKey, panel.innerHTML);
+        }
+      }
+    } finally {
+      for (const pre of sourceBlocks) {
+        if (pre.isConnected) {
+          pre.style.visibility = "";
+        }
+      }
+    }
+  }
+  var PYODIDE_VERSION = "v0.27.0";
+  var WEBR_VERSION = "v0.4.2";
+  var PYODIDE_CDN_BASE = `https://cdn.jsdelivr.net/pyodide/${PYODIDE_VERSION}/full`;
+  var WEBR_CDN_BASE = `https://webr.r-wasm.org/${WEBR_VERSION}`;
+  var PYODIDE_CACHE_NAME = `oml-pyodide-${PYODIDE_VERSION}`;
+  var WEBR_CACHE_NAME = `oml-webr-${WEBR_VERSION}`;
+  var RUNTIME_CACHE_PREFIXES = ["oml-pyodide-", "oml-webr-"];
+  var runtimeCacheInterceptors = /* @__PURE__ */ new Map();
+  var _originalFetch = globalThis.fetch.bind(globalThis);
+  if ("caches" in globalThis) {
+    globalThis.fetch = async (input, init) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      for (const [prefix, cacheName] of runtimeCacheInterceptors) {
+        if (url.startsWith(prefix)) {
+          try {
+            const cache5 = await caches.open(cacheName);
+            const hit = await cache5.match(url);
+            if (hit) {
+              return hit;
+            }
+            const response = await _originalFetch(input, init);
+            if (response.ok) {
+              await cache5.put(url, response.clone());
+            }
+            return response;
+          } catch {
+            break;
+          }
+        }
+      }
+      return _originalFetch(input, init);
+    };
+  }
+  async function pruneOldRuntimeCaches() {
+    if (!("caches" in globalThis)) {
+      return;
+    }
+    const current = /* @__PURE__ */ new Set([PYODIDE_CACHE_NAME, WEBR_CACHE_NAME]);
+    try {
+      const all = await caches.keys();
+      await Promise.all(
+        all.filter((n) => RUNTIME_CACHE_PREFIXES.some((p) => n.startsWith(p)) && !current.has(n)).map((n) => caches.delete(n))
+      );
+    } catch {
+    }
+  }
+  var pyodideInstance = null;
+  var pyodideLoading = null;
+  async function getPyodide() {
+    if (pyodideInstance) {
+      return pyodideInstance;
+    }
+    if (pyodideLoading) {
+      return pyodideLoading;
+    }
+    pyodideLoading = (async () => {
+      runtimeCacheInterceptors.set(PYODIDE_CDN_BASE, PYODIDE_CACHE_NAME);
+      const dynamicImport = new Function("url", "return import(url)");
+      const { loadPyodide } = await dynamicImport(`${PYODIDE_CDN_BASE}/pyodide.mjs`);
+      const py = await loadPyodide({ indexURL: `${PYODIDE_CDN_BASE}/` });
+      await py.loadPackage("micropip");
+      pyodideInstance = py;
+      return py;
+    })();
+    return pyodideLoading;
+  }
+  var PY_BOOTSTRAP = `
+def display(html):
+    _js_display(str(html))
+
+async def query(sparql):
+    result = _js_query(sparql)
+    return result.to_py() if hasattr(result, 'to_py') else result
+
+async def load(package):
+    import micropip as _micropip
+    await _micropip.install(package)
+
+def table(data):
+    rows, columns = [], []
+    if isinstance(data, dict) and 'rows' in data:
+        rows = data['rows']
+        columns = data.get('columns', list(rows[0].keys()) if rows else [])
+    elif isinstance(data, list) and data and isinstance(data[0], dict):
+        rows, columns = data, list(data[0].keys())
+    else:
+        try:
+            import pandas as _pd
+            if isinstance(data, _pd.DataFrame):
+                columns, rows = list(data.columns), data.to_dict('records')
+        except ImportError:
+            pass
+    if not rows or not columns:
+        display(str(data))
+        return
+    def _e(s):
+        return str(s).replace('&','&amp;').replace('<','&lt;').replace('>','&gt;')
+    hdr = ''.join(f'<th>{_e(c)}</th>' for c in columns)
+    bdy = ''.join(
+        f'<tr>{"".join(f"<td>{_e(r.get(c,"") if isinstance(r,dict) else "")}</td>" for c in columns)}</tr>'
+        for r in rows
+    )
+    display(f'<div class="oml-md-table-wrapper"><table class="oml-md-table"><thead><tr>{hdr}</tr></thead><tbody>{bdy}</tbody></table></div>')
+`;
+  var pyodideExecQueue = Promise.resolve();
+  async function executePyCode(code2, blockCache, container) {
+    let resolve4;
+    const queued = new Promise((res) => {
+      resolve4 = res;
+    });
+    pyodideExecQueue = pyodideExecQueue.then(() => _executePyCode(code2, blockCache, container).then(resolve4, (e) => resolve4({ error: String(e) })));
+    return queued;
+  }
+  async function _executePyCode(code2, blockCache, container) {
+    if (!container.isConnected) {
+      return {};
+    }
+    let statusEl = document.createElement("div");
+    statusEl.className = "oml-md-js-text-output";
+    statusEl.textContent = "Running Python block\u2026";
+    container.appendChild(statusEl);
+    const clearStatus = () => {
+      if (statusEl?.parentElement === container) {
+        container.removeChild(statusEl);
+      }
+      statusEl = void 0;
+    };
+    const appendHtml = (html2) => {
+      clearStatus();
+      const el = document.createElement("div");
+      el.className = "oml-md-js-html-output";
+      el.style.color = window.getComputedStyle(document.body).color;
+      el.innerHTML = html2;
+      container.appendChild(el);
+    };
+    const appendText = (text4) => {
+      clearStatus();
+      const pre = document.createElement("pre");
+      pre.className = "oml-md-js-text-output";
+      pre.textContent = text4;
+      container.appendChild(pre);
+    };
+    let pyodide;
+    try {
+      pyodide = await getPyodide();
+    } catch (e) {
+      clearStatus();
+      return { error: `Failed to load Pyodide: ${e instanceof Error ? e.message : String(e)}` };
+    }
+    try {
+      await pyodide.runPythonAsync(PY_BOOTSTRAP);
+    } catch (e) {
+      clearStatus();
+      return { error: `Python bootstrap failed: ${e instanceof Error ? e.message : String(e)}` };
+    }
+    pyodide.globals.set("_js_display", appendHtml);
+    pyodide.globals.set("_js_query", (sparql) => blockCache[sparql] ?? { success: false, columns: [], rows: [], error: "SPARQL not pre-fetched" });
+    pyodide.setStdout({ batched: appendText });
+    pyodide.setStderr({ batched: () => {
+    } });
+    try {
+      await pyodide.runPythonAsync(code2);
+      clearStatus();
+      return {};
+    } catch (error2) {
+      clearStatus();
+      return { error: error2 instanceof Error ? `${error2.name}: ${error2.message}` : String(error2) };
+    }
+  }
+  async function applyPyBlocks() {
+    const cache5 = getScriptSparqlCache();
+    for (const code2 of Array.from(document.querySelectorAll("pre > code.language-python"))) {
+      const pre = code2.parentElement;
+      const blockId = pre.dataset.omlBlockId ?? "";
+      const blockCache = cache5[blockId] ?? {};
+      const source = code2.textContent ?? "";
+      const cacheKey = buildPythonPanelCacheKey(blockId, source, blockCache);
+      const cachedHtml = pythonPanelHtmlCache[cacheKey];
+      if (typeof cachedHtml === "string") {
+        const panel2 = makeScriptPanel();
+        panel2.innerHTML = cachedHtml;
+        pre.replaceWith(panel2);
+        continue;
+      }
+      const panel = makeScriptPanel();
+      pre.replaceWith(panel);
+      const result = await executePyCode(source, blockCache, panel);
+      appendResult(panel, result);
+      if (!result.error) {
+        rememberPythonPanelCache(cacheKey, panel.innerHTML);
+      }
+    }
+  }
+  var webRInstance = null;
+  var webRLoading = null;
+  async function getWebR() {
+    if (webRInstance) {
+      return webRInstance;
+    }
+    if (webRLoading) {
+      return webRLoading;
+    }
+    webRLoading = (async () => {
+      runtimeCacheInterceptors.set(WEBR_CDN_BASE, WEBR_CACHE_NAME);
+      const dynamicImport = new Function("url", "return import(url)");
+      const { WebR: WebRClass } = await dynamicImport(`${WEBR_CDN_BASE}/webr.mjs`);
+      const webR = new WebRClass();
+      await webR.init();
+      webRInstance = webR;
+      return webR;
+    })();
+    return webRLoading;
+  }
+  var R_DISPLAY_SENTINEL = "<<OML_DISPLAY>>";
+  var R_DISPLAY_END = "<</OML_DISPLAY>>";
+  var R_BOOTSTRAP = `
+display <- function(html) {
+    .oml_buf_ <<- c(.oml_buf_, paste0('<<OML_DISPLAY>>', html, '<</OML_DISPLAY>>'))
+}
+table <- function(data) {
+    if (is.data.frame(data) || is.matrix(data)) {
+        df <- as.data.frame(data)
+        cols <- colnames(df)
+        hdr <- paste0('<th>', cols, '</th>', collapse='')
+        rows <- apply(df, 1, function(r) {
+            cells <- paste0('<td>', r, '</td>', collapse='')
+            paste0('<tr>', cells, '</tr>')
+        })
+        bdy <- paste(rows, collapse='')
+        display(paste0('<div class="oml-md-table-wrapper"><table class="oml-md-table"><thead><tr>',
+                       hdr, '</tr></thead><tbody>', bdy, '</tbody></table></div>'))
+    } else { print(data) }
+}
+load <- function(pkg) {
+    if (!requireNamespace(pkg, quietly=TRUE)) { webr::install(pkg) }
+    library(pkg, character.only=TRUE)
+}
+`;
+  function buildRDataFrameCode(result, varName) {
+    const rStr = (s) => '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "") + '"';
+    if (!result.success) {
+      return `${varName} <- (function() stop(${rStr(result.error ?? "SPARQL query failed")}))()`;
+    }
+    if (result.rows.length === 0) {
+      const colDefs2 = result.columns.map((c) => `  ${rStr(c)} = character(0)`).join(",\n");
+      return `${varName} <- data.frame(${colDefs2 ? "\n" + colDefs2 + ",\n" : ""}  stringsAsFactors = FALSE, check.names = FALSE)`;
+    }
+    const colDefs = result.columns.map((col) => {
+      const vals = result.rows.map((row) => rStr(String(row[col] ?? ""))).join(", ");
+      return `  ${rStr(col)} = c(${vals})`;
+    }).join(",\n");
+    return `${varName} <- data.frame(
+${colDefs},
+  stringsAsFactors = FALSE, check.names = FALSE
+)`;
+  }
+  function extractRQueryStrings(code2) {
+    const re = /\bquery\s*\(\s*(?:"((?:[^"\\]|\\[\s\S])*)"|'((?:[^'\\]|\\[\s\S])*)')\s*\)/g;
+    const seen = /* @__PURE__ */ new Set();
+    let m;
+    while ((m = re.exec(code2)) !== null) {
+      const raw2 = m[1] ?? m[2];
+      const unesc = raw2.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+      seen.add(unesc);
+    }
+    return [...seen];
+  }
+  function rewriteRQueryCalls(code2, queryMap) {
+    const re = /\bquery\s*\(\s*(?:"((?:[^"\\]|\\[\s\S])*)"|'((?:[^'\\]|\\[\s\S])*)')\s*\)/g;
+    return code2.replace(re, (_2, dq, sq) => {
+      const raw2 = dq ?? sq;
+      const sparql = raw2.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+      return queryMap.get(sparql) ?? "data.frame()";
+    });
+  }
+  function processROutput(raw2, appendHtml, appendText) {
+    let remaining = raw2;
+    while (remaining.length > 0) {
+      const start = remaining.indexOf(R_DISPLAY_SENTINEL);
+      if (start === -1) {
+        if (remaining.trim()) {
+          appendText(remaining);
+        }
+        break;
+      }
+      if (start > 0) {
+        appendText(remaining.slice(0, start));
+      }
+      const end = remaining.indexOf(R_DISPLAY_END, start + R_DISPLAY_SENTINEL.length);
+      if (end === -1) {
+        appendText(remaining.slice(start));
+        break;
+      }
+      appendHtml(remaining.slice(start + R_DISPLAY_SENTINEL.length, end));
+      remaining = remaining.slice(end + R_DISPLAY_END.length);
+    }
+  }
+  async function executeRCode(code2, blockCache, container) {
+    let statusEl = document.createElement("div");
+    statusEl.className = "oml-md-js-text-output";
+    statusEl.textContent = "Running R block\u2026";
+    container.appendChild(statusEl);
+    const clearStatus = () => {
+      if (statusEl?.parentElement === container) {
+        container.removeChild(statusEl);
+      }
+      statusEl = void 0;
+    };
+    const appendHtml = (html2) => {
+      clearStatus();
+      const el = document.createElement("div");
+      el.className = "oml-md-js-html-output";
+      el.style.color = window.getComputedStyle(document.body).color;
+      el.innerHTML = html2;
+      container.appendChild(el);
+    };
+    const appendText = (text4) => {
+      clearStatus();
+      const pre = document.createElement("pre");
+      pre.className = "oml-md-js-text-output";
+      pre.textContent = text4;
+      container.appendChild(pre);
+    };
+    const queryStrings = extractRQueryStrings(code2);
+    const prefetchResults = queryStrings.map((sparql, i) => {
+      const varName = `.oml_q${i}_`;
+      const result = blockCache[sparql] ?? { success: false, columns: [], rows: [], error: "SPARQL not pre-fetched" };
+      return { sparql, varName, preamble: buildRDataFrameCode(result, varName) };
+    });
+    let webR;
+    try {
+      webR = await getWebR();
+    } catch (e) {
+      clearStatus();
+      return { error: `Failed to load WebR: ${e instanceof Error ? e.message : String(e)}` };
+    }
+    try {
+      await webR.evalRVoid(R_BOOTSTRAP);
+    } catch (e) {
+      clearStatus();
+      return { error: `R bootstrap failed: ${e instanceof Error ? e.message : String(e)}` };
+    }
+    let finalCode = code2;
+    if (prefetchResults.length > 0) {
+      const queryMap = new Map(prefetchResults.map((r) => [r.sparql, r.varName]));
+      finalCode = prefetchResults.map((r) => r.preamble).join("\n") + "\n" + rewriteRQueryCalls(code2, queryMap);
+    }
+    try {
+      await webR.evalRVoid(
+        ".oml_buf_ <- character(0)\ntryCatch({\n" + finalCode + '\n}, error = function(e) { .oml_buf_ <<- c(.oml_buf_, paste0("Error: ", conditionMessage(e))) })\n'
+      );
+      const rawOutput = await webR.evalRString('paste(.oml_buf_, collapse="")');
+      processROutput(rawOutput, appendHtml, appendText);
+      clearStatus();
+      return {};
+    } catch (error2) {
+      clearStatus();
+      return { error: error2 instanceof Error ? `${error2.name}: ${error2.message}` : String(error2) };
+    }
+  }
+  async function applyRBlocks() {
+    const cache5 = getScriptSparqlCache();
+    for (const code2 of Array.from(document.querySelectorAll("pre > code.language-r"))) {
+      const pre = code2.parentElement;
+      const blockId = pre.dataset.omlBlockId ?? "";
+      const blockCache = cache5[blockId] ?? {};
+      const source = code2.textContent ?? "";
+      const cacheKey = buildRPanelCacheKey(blockId, source, blockCache);
+      const cachedHtml = rPanelHtmlCache[cacheKey];
+      if (typeof cachedHtml === "string") {
+        const panel2 = makeScriptPanel();
+        panel2.innerHTML = cachedHtml;
+        pre.replaceWith(panel2);
+        continue;
+      }
+      const panel = makeScriptPanel();
+      pre.replaceWith(panel);
+      const result = await executeRCode(source, blockCache, panel);
+      appendResult(panel, result);
+      if (!result.error) {
+        rememberRPanelCache(cacheKey, panel.innerHTML);
+      }
+    }
+  }
+  void bootstrapStaticRender();
 })();
 /*! Bundled license information: