@vizhub/runtime 4.1.0 → 4.3.0

package/dist/build-BT6ouBQg.js

@@ -0,0 +1,1216 @@
+import { magicSandbox as C } from "magic-sandbox";
+import { isVizId as G, getFileText as B, generateVizId as Y, fileCollectionToVizFiles as Q, vizFilesToFileCollection as X } from "@vizhub/viz-utils";
+import { transform as Z } from "sucrase";
+const We = () => (Math.random() + "").slice(2);
+function V(e = {}) {
+  return {
+    name: "sucrase",
+    transform(t, n) {
+      if (!n.match(/\.(?:js|[jt]sx)$/))
+        return null;
+      const s = Z(t, {
+        transforms: ["jsx", "typescript"],
+        // For source maps
+        filePath: n,
+        sourceMapOptions: {
+          compiledFilename: "bundle.js"
+        },
+        production: !0,
+        ...e
+      });
+      return {
+        code: s.code,
+        map: s.sourceMap
+      };
+    }
+  };
+}
+const P = {
+  dependencies: {},
+  vizhub: {},
+  license: "MIT"
+}, K = !1, $ = (e) => {
+  const t = e["package.json"];
+  try {
+    const n = t ? JSON.parse(t) : P;
+    return K && console.log(
+      "[packageJSON] pkg:",
+      JSON.stringify(n, null, 2)
+    ), n;
+  } catch {
+    return P;
+  }
+}, L = (e) => $(e).dependencies || {}, z = (e) => ($(e).vizhub || {}).libraries || {}, F = ({ name: e, version: t }, n, s = "jsdelivr") => {
+  const r = n[e] && n[e].path || "";
+  return s === "jsdelivr" ? `https://cdn.jsdelivr.net/npm/${e}@${t}${r}` : `https://unpkg.com/${e}@${t}${r}`;
+}, ee = (e) => {
+  const t = e?.vizhub?.libraries;
+  return t ? Object.entries(t).reduce(
+    (n, [s, r]) => (r.global && (n[s] = r.global), n),
+    {}
+  ) : {};
+}, te = {
+  d3: "d3",
+  react: "React",
+  "react-dom": "ReactDOM"
+}, H = (e) => {
+  const t = ee(e);
+  return {
+    ...te,
+    ...t
+  };
+}, S = (e) => {
+  const [t, ...n] = e.split("/"), s = n.join("/");
+  return { vizId: t, fileName: s };
+}, ne = `var EOL = {},
+  EOF = {},
+  QUOTE = 34,
+  NEWLINE = 10,
+  RETURN = 13;
+
+function objectConverter(columns) {
+  return new Function(
+    'd',
+    'return {' +
+      columns
+        .map(function (name, i) {
+          return (
+            JSON.stringify(name) + ': d[' + i + '] || ""'
+          );
+        })
+        .join(',') +
+      '}',
+  );
+}
+
+function customConverter(columns, f) {
+  var object = objectConverter(columns);
+  return function (row, i) {
+    return f(object(row), i, columns);
+  };
+}
+
+function dsv(delimiter) {
+  var DELIMITER = delimiter.charCodeAt(0);
+
+  function parse(text, f) {
+    var convert,
+      columns,
+      rows = parseRows(text, function (row, i) {
+        if (convert) return convert(row, i - 1);
+        (columns = row),
+          (convert = f
+            ? customConverter(row, f)
+            : objectConverter(row));
+      });
+    rows.columns = columns || [];
+    return rows;
+  }
+
+  function parseRows(text, f) {
+    var rows = [], // output rows
+      N = text.length,
+      I = 0, // current character index
+      n = 0, // current line number
+      t, // current token
+      eof = N <= 0, // current token followed by EOF?
+      eol = false; // current token followed by EOL?
+
+    // Strip the trailing newline.
+    if (text.charCodeAt(N - 1) === NEWLINE) --N;
+    if (text.charCodeAt(N - 1) === RETURN) --N;
+
+    function token() {
+      if (eof) return EOF;
+      if (eol) return (eol = false), EOL;
+
+      // Unescape quotes.
+      var i,
+        j = I,
+        c;
+      if (text.charCodeAt(j) === QUOTE) {
+        while (
+          (I++ < N && text.charCodeAt(I) !== QUOTE) ||
+          text.charCodeAt(++I) === QUOTE
+        );
+        if ((i = I) >= N) eof = true;
+        else if ((c = text.charCodeAt(I++)) === NEWLINE)
+          eol = true;
+        else if (c === RETURN) {
+          eol = true;
+          if (text.charCodeAt(I) === NEWLINE) ++I;
+        }
+        return text.slice(j + 1, i - 1).replace(/""/g, '"');
+      }
+
+      // Find next delimiter or newline.
+      while (I < N) {
+        if ((c = text.charCodeAt((i = I++))) === NEWLINE)
+          eol = true;
+        else if (c === RETURN) {
+          eol = true;
+          if (text.charCodeAt(I) === NEWLINE) ++I;
+        } else if (c !== DELIMITER) continue;
+        return text.slice(j, i);
+      }
+
+      // Return last token before EOF.
+      return (eof = true), text.slice(j, N);
+    }
+
+    while ((t = token()) !== EOF) {
+      var row = [];
+      while (t !== EOL && t !== EOF)
+        row.push(t), (t = token());
+      if (f && (row = f(row, n++)) == null) continue;
+      rows.push(row);
+    }
+
+    return rows;
+  }
+
+  return {
+    parse: parse,
+  };
+}
+
+var csv = dsv(',');
+
+var csvParse = csv.parse;
+
+var tsv = dsv('	');
+
+var tsvParse = tsv.parse;
+
+export { csvParse, tsvParse };`, re = (e) => (
+  // str.replace(/`/g, '\\`');
+  e.replace(/\\/g, "\\\\").replace(/`/g, "\\`")
+), se = () => ({
+  name: "transformDSV",
+  // `id` here is of the form
+  // `{vizId}/{fileName}`
+  transform: async (e, t) => {
+    const { fileName: n } = S(t), s = n.endsWith(".csv"), r = n.endsWith(".tsv");
+    if (s || r)
+      return {
+        code: `
+            ${ne}
+            const data = ${s ? "csvParse" : "tsvParse"}(\`${re(e)}\`);
+            export default data;
+          `,
+        map: { mappings: "" }
+      };
+  }
+}), oe = (e) => {
+  const t = /^@([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_-]+)$/, n = e.match(t);
+  return n ? {
+    userName: n[1],
+    idOrSlug: n[2]
+  } : null;
+}, ie = ({
+  vizId: e,
+  slugCache: t
+}) => ({
+  name: "vizResolve",
+  resolveId: async (n, s) => {
+    if (n.startsWith("./") && !s?.startsWith("https://")) {
+      let o = n.substring(2);
+      if (!o.endsWith(".js") && !o.endsWith(".css") && !o.endsWith(".csv") && !o.endsWith(".svelte") && (o += ".js"), s) {
+        const {
+          vizId: c,
+          fileName: i
+        } = S(s), a = i.split("/").slice(0, -1).join("/"), u = a ? `${a}/${o}` : o;
+        return `${c}/${u}`;
+      }
+      return e + "/" + o;
+    }
+    const r = oe(n);
+    if (r) {
+      let o;
+      if (G(r.idOrSlug))
+        o = r.idOrSlug;
+      else {
+        if (!t)
+          throw new Error(
+            "slugCache is required to import by slug in v3 runtime"
+          );
+        o = await t.get(
+          `${r.userName}/${r.idOrSlug}`
+        );
+      }
+      return o + "/index.js";
+    }
+  }
+}), ce = ({
+  vizCache: e,
+  trackCSSImport: t,
+  vizId: n,
+  files: s
+}) => ({
+  name: "vizLoad",
+  // `id` here is of the form
+  // `{vizId}/{fileName}`
+  load: async (r) => {
+    const o = S(r), c = o.vizId, i = o.fileName;
+    if (i.endsWith(".css"))
+      return t(r), "";
+    let a = null;
+    if (c === n && s)
+      a = s[i] || null;
+    else {
+      const u = await e.get(c);
+      a = B(u, i);
+    }
+    if (a === null)
+      throw new Error(
+        `Imported file "${i}" not found.`
+      );
+    return a;
+  }
+}), J = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map();
+let I;
+const E = "https://cdn.jsdelivr.net/npm/svelte@5.37.1", De = `${E}/compiler/index.js`;
+async function W(e) {
+  const t = R.get(e);
+  if (t)
+    return t;
+  const n = [".js", "/index.js"];
+  for (const r of n) {
+    const o = `${e}${r}`;
+    try {
+      if ((await fetch(o, { method: "HEAD" })).ok)
+        return R.set(e, o), o;
+    } catch {
+      continue;
+    }
+  }
+  const s = `${e}.js`;
+  return R.set(e, s), s;
+}
+const ae = ({
+  getSvelteCompiler: e
+}) => ({
+  name: "transformSvelte",
+  load: async (t) => {
+    if (t === "virtual:esm-env")
+      return `
+export const BROWSER = true;
+export const DEV = true;
+export const NODE = false;
+export const PROD = false;
+`;
+    if (!t.startsWith(E))
+      return;
+    const n = J.get(t);
+    if (n) return n;
+    const s = await fetch(t).then(
+      (r) => r.text()
+    );
+    return J.set(t, s), s;
+  },
+  // From https://github.com/sveltejs/sites/blob/master/packages/repl/src/lib/workers/bundler/index.js#L255C2-L271C5
+  resolveId: async (t, n) => {
+    if (t === "esm-env")
+      return "virtual:esm-env";
+    if (t === "svelte")
+      return `${E}/src/index-client.js`;
+    if (t.startsWith("svelte/")) {
+      const s = t.slice(7), r = `${E}/src/${s}`;
+      return await W(r);
+    }
+    if (t.startsWith("#client/")) {
+      const s = t.slice(8), r = `${E}/src/internal/client/${s}`;
+      return await W(r);
+    }
+    if (/^https?:/.test(t)) return t;
+    if (t.startsWith(".") && n && n.startsWith(E)) {
+      const s = new URL(t, n).href;
+      return new URL(t, n).href, s;
+    }
+  },
+  transform: async (t, n) => {
+    const { fileName: s } = S(n);
+    if (s.endsWith(".svelte")) {
+      if (!I) {
+        if (!e)
+          throw new Error("Svelte compiler not available");
+        I = await e();
+      }
+      const o = I(t, {
+        filename: s,
+        generate: "client",
+        // Svelte 5 uses 'client' instead of 'dom'
+        css: "external",
+        // Extract CSS instead of auto-injecting
+        dev: !1
+        // Production mode
+      });
+      let c = o.js.code;
+      return o.css && o.css.code && (c = `
+// Auto-inject CSS for Svelte component
+(function() {
+  if (typeof document !== 'undefined') {
+    const style = document.createElement('style');
+    style.textContent = ${JSON.stringify(o.css.code)};
+    document.head.appendChild(style);
+  }
+})();
+` + c), c;
+    }
+  }
+}), de = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0,
+  vizCache: s,
+  vizId: r,
+  slugCache: o,
+  getSvelteCompiler: c
+}) => {
+  const i = /* @__PURE__ */ new Set(), a = (p) => {
+    i.add(p);
+  };
+  if (!e["index.js"])
+    throw new Error("Missing index.js");
+  const d = {
+    name: "replace",
+    transform(p, w) {
+      let y = !1, f = p;
+      return f.includes("process.env.NODE_ENV") && (f = f.replace(
+        /\bprocess\.env\.NODE_ENV\b/g,
+        JSON.stringify("production")
+      ), y = !0), y ? { code: f, map: null } : null;
+    }
+  }, l = {
+    input: "./index.js",
+    plugins: [
+      ...r ? [ie({ vizId: r, slugCache: o })] : [],
+      se(),
+      V(),
+      ae({ getSvelteCompiler: c }),
+      d,
+      ...s ? [
+        ce({
+          vizCache: s,
+          trackCSSImport: a,
+          vizId: r,
+          files: e
+        })
+      ] : []
+    ],
+    onwarn(p, w) {
+      p.code !== "UNRESOLVED_IMPORT" && w(p);
+    }
+  }, m = {
+    format: "umd",
+    name: "Viz",
+    sourcemap: !!n,
+    compact: !0
+  }, g = $(e);
+  if (g) {
+    const p = H(g);
+    p && (l.external = Object.keys(p), m.globals = p);
+  }
+  l.external || (l.external = []), m.globals || (m.globals = {}), Array.isArray(l.external) && (l.external = l.external.filter(
+    (p) => typeof p == "string" && !p.startsWith("#client/")
+  ));
+  const v = await t(l), { output: b } = await v.generate(m);
+  return {
+    src: b[0].code,
+    cssFiles: Array.from(i)
+  };
+}, le = (e) => {
+  if (e instanceof Error) {
+    const t = e.stack || "", n = e.message || "Unknown error";
+    return `${e.name || "Error"}: ${n}
+${t}`;
+  } else if ("error" in e && e.error instanceof Error) {
+    const t = e.error, n = t.stack || "", s = t.message || "Unknown error", r = "filename" in e ? e.filename : "", o = "lineno" in e ? e.lineno : "", c = "colno" in e ? e.colno : "";
+    let i = "";
+    return r && o && (i = ` at ${r}:${o}`, c && (i += `:${c}`)), `${t.name || "Error"}: ${s}${i}
+${n}`;
+  } else if ("reason" in e) {
+    const t = e.reason;
+    if (t instanceof Error) {
+      const n = t.stack || "", s = t.message || "Unknown error";
+      return `Unhandled Promise Rejection - ${t.name || "Error"}: ${s}
+${n}`;
+    } else
+      return `Unhandled Promise Rejection: ${String(t)}`;
+  } else
+    return `Unknown runtime error: ${String(e)}`;
+}, j = () => `
+    // Global error handling for runtime errors
+    (() => {
+      const formatRuntimeError = ${le.toString()};
+      
+      // Handle uncaught JavaScript errors
+      window.addEventListener('error', (event) => {
+        const formattedErrorMessage = formatRuntimeError(event);
+        parent.postMessage({ 
+          type: 'runtimeError', 
+          formattedErrorMessage 
+        }, "*");
+      });
+      
+      // Handle unhandled promise rejections
+      window.addEventListener('unhandledrejection', (event) => {
+        const formattedErrorMessage = formatRuntimeError(event);
+        parent.postMessage({ 
+          type: 'runtimeError', 
+          formattedErrorMessage 
+        }, "*");
+      });
+    })();
+  `;
+function ue() {
+  return Math.random().toString().slice(2, 7);
+}
+const pe = ({
+  cdn: e,
+  src: t,
+  styles: n
+}) => {
+  const r = `viz-container-${ue()}`;
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">${e}${n}
+  <style>
+    body {
+      margin: 0;
+      overflow: hidden;
+    }
+    #${r} {
+      height: 100vh;
+    }
+  </style>
+</head>
+<body>
+  <div id="${r}"></div>
+  <script>${j()}<\/script>
+  <script id="injected-script">${t}<\/script>
+  <script>
+    (() => {
+      let cleanup;
+      const render = () => {
+        const container = document.getElementById('${r}');
+        typeof cleanup === 'function' && cleanup();
+        cleanup = (Viz.viz || Viz.main)(container, { state: window.state, setState, writeFile });
+      };
+      const setState = (next) => {
+        window.state = next(window.state);
+        render();
+      };
+      const writeFile = (fileName, content) => {
+        parent.postMessage({ type: 'writeFile', fileName, content }, "*");
+      };
+      const run = () => {
+        try {
+          setState((state) => state || {});
+        } catch (error) {
+          console.error(error);
+          parent.postMessage({ type: 'runError', error }, "*");
+        }
+      }
+      run();
+      const runJS = (src) => {
+        document.getElementById('injected-script')?.remove();
+        const script = document.createElement('script');
+        script.textContent = src;
+        script.id = 'injected-script';
+        document.body.appendChild(script);
+        run();
+      };
+      const runCSS = (css) => {
+        let style = document.getElementById('injected-style');
+        if (!style) {
+          style = document.createElement('style');
+          style.type = 'text/css';
+          style.id = 'injected-style';
+          document.head.appendChild(style);
+        }
+        style.textContent = css;
+      };
+      onmessage = (message) => {
+        switch (message.data.type) {
+          case 'runJS':
+            runJS(message.data.js);
+            parent.postMessage({ type: 'runDone' }, "*");
+            break;
+          case 'runCSS':
+            runCSS(message.data.css);
+            break;
+          case 'ping':
+            parent.postMessage({ type: 'pong' }, "*");
+            break;
+          default:
+            break;
+        }
+      }
+    })();
+  <\/script>
+</body>
+</html>`;
+}, me = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0,
+  vizCache: s,
+  vizId: r,
+  slugCache: o,
+  getSvelteCompiler: c
+}) => {
+  const { src: i, cssFiles: a } = await de({
+    files: e,
+    rollup: t,
+    enableSourcemap: n,
+    vizCache: s,
+    vizId: r,
+    slugCache: o,
+    getSvelteCompiler: c
+  });
+  let u = [];
+  if (a.length > 0)
+    for (let v = 0; v < a.length; v++) {
+      const b = a[v], p = S(b), w = p.vizId, y = p.fileName;
+      let f = null;
+      if (w === r && e)
+        f = e[y] || null;
+      else {
+        const q = await s.get(w);
+        f = B(q, y);
+      }
+      f && u.push(f);
+    }
+  const d = u.join(`
+`), l = `
+    <style id="injected-style">${d}</style>`;
+  let m = "";
+  const g = Object.entries(
+    L(e)
+  );
+  if (g.length > 0) {
+    const v = z(e);
+    m = g.map(([b, p], w) => {
+      const y = F(
+        { name: b, version: p },
+        v
+      );
+      return `${w > 0 ? "    " : `
+    `}<script src="${y}"><\/script>`;
+    }).join("");
+  }
+  return {
+    html: pe({ cdn: m, src: i, styles: l }),
+    css: d,
+    js: i,
+    runtimeVersion: "v3"
+  };
+}, fe = ({
+  initialContents: e,
+  handleCacheMiss: t
+}) => {
+  const n = new Map(
+    e.map((c) => [c.id, c])
+  );
+  return { get: async (c) => {
+    const i = n.get(c);
+    if (i !== void 0)
+      return i;
+    if (!t)
+      throw new Error(
+        `Unresolved import from vizId ${c}, cache miss handler not provided.`
+      );
+    const a = await t(c);
+    if (a)
+      return n.set(c, a), a;
+    throw new Error(
+      `Unresolved import from vizId ${c}`
+    );
+  }, set: (c) => {
+    n.set(c.id, c);
+  }, invalidate: (c) => {
+    n.delete(c);
+  } };
+}, Ue = ({
+  initialMappings: e = {},
+  handleCacheMiss: t
+}) => ({ get: async (o) => {
+  const c = e[o];
+  if (c !== void 0)
+    return c;
+  if (!t)
+    throw new Error(
+      `Unresolved slug ${o}, cache miss handler not provided.`
+    );
+  const i = await t(o);
+  if (i)
+    return e[o] = i, i;
+  throw new Error(`Unresolved slug ${o}`);
+}, set: (o, c) => {
+  e[o] = c;
+}, invalidate: (o) => {
+  delete e[o];
+} }), he = (e, t = "Sample Content for Exporting", n = Y()) => ({
+  id: n,
+  files: Q(e),
+  title: t
+}), ge = (e) => {
+  if (Object.keys(e).length === 0)
+    return null;
+  const t = "index.html" in e, n = "index.js" in e, s = "index.jsx" in e;
+  return t ? e["index.html"].includes('type="module"') ? "v4" : n || s ? "v2" : "v1" : !t && n ? "v3" : null;
+}, O = (e, t) => new RegExp(`<${t}\\b`, "i").test(e) && new RegExp(`</${t}>`, "i").test(e), ve = (e) => {
+  const t = e.trim();
+  return O(t, "html") && O(t, "head") && O(t, "body") ? t : `<html><head></head><body>${t}</body></html>`;
+}, we = (e, t) => e.replace(
+  new RegExp(
+    `<script[^>]*src=["'][^"']*${t.source}[^"']*["'][^>]*>\\s*<\/script>`,
+    "gi"
+  ),
+  ""
+), N = (e, t, n) => e.replace(
+  new RegExp(t, "i"),
+  `${n}${t}`
+), ye = (e, t) => {
+  let n = ve(e);
+  const s = Object.entries(L(t));
+  if (s.length) {
+    const c = z(t);
+    s.forEach(([a]) => {
+      n = we(n, new RegExp(`${a}@`));
+    });
+    const i = s.map(
+      ([a, u]) => F({ name: a, version: u }, c)
+    ).map((a) => `<script src="${a}"><\/script>`).join(`
+`);
+    n = N(
+      n,
+      "</head>",
+      i + `
+`
+    );
+  }
+  if (t["bundle.js"] !== void 0 || t["index.js"] !== void 0) {
+    const c = '<script src="bundle.js"><\/script>', i = /<script\b[^>]*\bsrc=["']bundle\.js["'][^>]*>\s*<\/script>/gi, a = [...n.matchAll(i)];
+    a.length === 1 && (() => {
+      const d = a[0].index ?? -1;
+      if (d === -1) return !1;
+      const l = n.search(/<body\b[^>]*>/i), m = n.search(/<\/body>/i);
+      return l !== -1 && m !== -1 && d > l && d < m;
+    })() || (n = n.replace(i, ""), n = N(n, "</body>", c));
+  }
+  const o = `<script>${j()}<\/script>
+`;
+  return n = N(
+    n,
+    "</head>",
+    o
+  ), /^\s*<!DOCTYPE/i.test(n) ? n : `<!DOCTYPE html>${n}`;
+}, Ee = (e) => {
+  const t = e["index.html"];
+  return !t && !e["index.js"] && !e["bundle.js"] ? "" : ye(t || "<!DOCTYPE html><html><head></head><body></body></html>", e);
+};
+function be(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var k, D;
+function xe() {
+  return D || (D = 1, k = {
+    d3: "d3",
+    "d3-array": "d3",
+    "d3-axis": "d3",
+    "d3-brush": "d3",
+    "d3-chord": "d3",
+    "d3-collection": "d3",
+    "d3-color": "d3",
+    "d3-contour": "d3",
+    "d3-dispatch": "d3",
+    "d3-drag": "d3",
+    "d3-dsv": "d3",
+    "d3-ease": "d3",
+    "d3-fetch": "d3",
+    "d3-force": "d3",
+    "d3-format": "d3",
+    "d3-geo": "d3",
+    "d3-hierarchy": "d3",
+    "d3-interpolate": "d3",
+    "d3-path": "d3",
+    "d3-polygon": "d3",
+    "d3-quadtree": "d3",
+    "d3-random": "d3",
+    "d3-scale": "d3",
+    "d3-scale-chromatic": "d3",
+    "d3-selection": "d3",
+    "d3-shape": "d3",
+    "d3-tile": "d3",
+    "d3-time": "d3",
+    "d3-time-format": "d3",
+    "d3-timer": "d3",
+    "d3-transition": "d3",
+    "d3-voronoi": "d3",
+    "d3-zoom": "d3",
+    react: "React",
+    "react-dom": "ReactDOM",
+    "react-dropdown-browser": "ReactDropdown",
+    "react-dropdown": "ReactDropdown",
+    three: "THREE",
+    vega: "vega",
+    "vega-embed": "vegaEmbed",
+    "vega-lite": "vegaLite",
+    "vega-lite-api": "vl",
+    "vega-tooltip": "vegaTooltip",
+    "vega-themes": "vegaThemes",
+    "vizhub-vega-lite-config": "vizhubVegaLiteConfig",
+    semiotic: "Semiotic",
+    "viz.js": "Viz"
+  }), k;
+}
+var Se = xe();
+const $e = /* @__PURE__ */ be(Se), h = "\0virtual:", U = (e) => {
+  let t = e.replace(/^\.\//, "");
+  return t = t.replace(/\/+/g, "/"), t = t.replace(/\/$/, ""), t;
+}, je = (e, t) => {
+  const n = e.includes("/") ? e.slice(0, e.lastIndexOf("/")) : "", s = t.split("/"), r = n ? n.split("/") : [];
+  for (const o of s)
+    o === ".." ? r.pop() : o !== "." && o !== "" && r.push(o);
+  return r.join("/");
+}, _ = (e) => ({
+  name: "virtual-file-system",
+  resolveId(t, n) {
+    const s = n?.startsWith(
+      h
+    ) ? n.slice(h.length) : n;
+    if (t.startsWith("./") || t.startsWith("../")) {
+      const o = U(s ? je(s, t) : t);
+      if (e[o])
+        return h + o;
+      const c = [".js", ".jsx", ".ts", ".tsx"];
+      for (const i of c) {
+        const a = o + i;
+        if (e[a])
+          return h + a;
+      }
+    }
+    if (e[t])
+      return h + t;
+    const r = [".js", ".jsx", ".ts", ".tsx"];
+    for (const o of r) {
+      const c = t + o;
+      if (e[c])
+        return h + c;
+    }
+    return null;
+  },
+  load(t) {
+    if (t.startsWith(h)) {
+      const n = t.slice(h.length);
+      if (e[n])
+        return e[n];
+    }
+    return null;
+  }
+}), Ce = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0
+}) => {
+  let s = "index.js";
+  if (!e[s] && (s = "index.jsx", !e[s]))
+    throw new Error(
+      "Missing entry point, can't find index.js or index.jsx"
+    );
+  const o = {
+    input: "./" + s,
+    plugins: [_(e), V()],
+    onwarn(d, l) {
+      d.code !== "UNRESOLVED_IMPORT" && l(d);
+    }
+  }, c = {
+    format: "iife",
+    sourcemap: n
+  }, i = $(e);
+  if (i) {
+    const d = {
+      // Pre-configured globals for v2 only
+      ...$e,
+      // Libraries from package.json
+      ...H(i)
+    };
+    d && (o.external = Object.keys(d), c.globals = d);
+  }
+  const a = await t(o), { output: u } = await a.generate(c);
+  return u[0].code;
+}, Re = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n
+}) => ({
+  ...e,
+  "bundle.js": await Ce({
+    files: e,
+    rollup: t,
+    enableSourcemap: n
+  }),
+  "index.html": Ee(e)
+}), Ie = (e) => {
+  const t = [], n = [], s = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+  let r, o = 0;
+  for (; (r = s.exec(e)) !== null; ) {
+    const c = r[1], i = r[2];
+    if (!/\btype\s*=\s*["']module["']/i.test(c))
+      continue;
+    const a = c.match(
+      /\bsrc\s*=\s*["']([^"']+)["']/i
+    );
+    if (a)
+      t.push(a[1]);
+    else if (i.trim()) {
+      const u = `__inline_script_${o++}.js`;
+      n.push({
+        id: u,
+        content: i.trim()
+      }), t.push(u);
+    }
+  }
+  return { entryPoints: t, inlineScripts: n };
+}, Oe = () => ({
+  name: "catch-all-prevent-fs",
+  resolveId(e, t) {
+    return { id: e, external: !0 };
+  }
+}), Ne = async ({
+  entryPoint: e,
+  files: t,
+  rollup: n,
+  enableSourcemap: s = !0
+}) => {
+  const o = {
+    input: e.startsWith("./") ? e : `./${e}`,
+    plugins: [
+      _(t),
+      V({
+        // Enable JSX runtime
+        // so we don't need to import React
+        // in every file that uses JSX
+        jsxRuntime: "automatic"
+      }),
+      Oe()
+    ],
+    // external: (source: string) => {
+    //   DEBUG && console.log("external", source);
+    //   // Handle strings resolved by `virtualFileSystem`.
+    //   const isVirtualFile = source.startsWith("./");
+    //   // Handle external dependencies, e.g. from import maps.
+    //   const isLibrary = !source.startsWith("./");
+    //   const isExternal = !isVirtualFile || isLibrary;
+    //   DEBUG && console.log("isExternal", isExternal);
+    //   return isExternal;
+    // },
+    onwarn(a, u) {
+    }
+  }, c = await n(o), { output: i } = await c.generate({
+    format: "es",
+    sourcemap: s
+  });
+  return i[0].code;
+}, T = (e, t) => new RegExp(`<${t}\\b`, "i").test(e) && new RegExp(`</${t}>`, "i").test(e), ke = (e) => {
+  const t = e.trim();
+  return T(t, "html") && T(t, "head") && T(t, "body") ? t : `<html><head></head><body>${t}</body></html>`;
+}, A = (e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), M = (e, t, n) => e.replace(
+  new RegExp(t, "i"),
+  `${n}${t}`
+), Te = (e) => {
+  const t = L(e);
+  if (Object.keys(t).length === 0) return null;
+  const n = z(e), s = {};
+  for (const [r, o] of Object.entries(t))
+    s[r] = F(
+      { name: r, version: o },
+      n
+    );
+  return JSON.stringify({ imports: s }, null, 2);
+}, Me = () => `
+    // V4 Hot Reloading Support
+    (() => {
+      const runJS = (js) => {
+        // Remove all existing bundled module scripts
+        const existingScripts = document.querySelectorAll('script[type="module"]');
+        existingScripts.forEach(script => {
+          // Only remove scripts that contain bundled code (not import maps or external scripts)
+          if (script.textContent && script.textContent.trim()) {
+            script.remove();
+          }
+        });
+        
+        // Create new script with updated bundled code
+        const script = document.createElement('script');
+        script.type = 'module';
+        script.textContent = js;
+        document.body.appendChild(script);
+      };
+      
+      const runCSS = (css) => {
+        let style = document.getElementById('v4-injected-style');
+        if (!style) {
+          style = document.createElement('style');
+          style.type = 'text/css';
+          style.id = 'v4-injected-style';
+          document.head.appendChild(style);
+        }
+        style.textContent = css;
+      };
+      
+      // Listen for hot reload messages
+      window.addEventListener('message', (message) => {
+        switch (message.data.type) {
+          case 'runJS':
+            try {
+              runJS(message.data.js);
+              parent.postMessage({ type: 'runDone' }, "*");
+            } catch (error) {
+              console.error('V4 Hot reload error:', error);
+              parent.postMessage({ type: 'runError', error }, "*");
+            }
+            break;
+          case 'runCSS':
+            runCSS(message.data.css);
+            break;
+          case 'ping':
+            parent.postMessage({ type: 'pong' }, "*");
+            break;
+          default:
+            break;
+        }
+      });
+    })();
+  `, Ve = (e, t, n = [], s = !1) => {
+  if (!e["index.html"]) return "";
+  let r = ke(e["index.html"]);
+  t.forEach((i, a) => {
+    if (n.some(
+      (d) => d.id === a
+    )) {
+      const d = n.find((g) => g.id === a)?.content || "", l = A(
+        d
+      ), m = new RegExp(
+        `<script\\b[^>]*\\btype=["']module["'][^>]*>\\s*${l}\\s*<\/script>`,
+        "gi"
+      );
+      r = r.replace(
+        m,
+        `<script type="module">
+${i}
+<\/script>`
+      );
+    } else {
+      const d = new RegExp(
+        `<script\\b[^>]*\\bsrc=["']${A(a)}["'][^>]*>[^<]*<\/script>`,
+        "gi"
+      );
+      r = r.replace(
+        d,
+        `<script type="module">
+${i}
+<\/script>`
+      );
+    }
+  });
+  const o = Te(e);
+  if (o && !/<script\b[^>]*type=["']importmap["'][^>]*>/i.test(
+    r
+  )) {
+    const a = `<script type="importmap">
+${o}
+<\/script>
+`;
+    r = M(
+      r,
+      "</head>",
+      a
+    );
+  }
+  const c = `<script>${j()}<\/script>
+`;
+  if (r = M(
+    r,
+    "</head>",
+    c
+  ), s) {
+    const i = `<script>${Me()}<\/script>
+`;
+    r = M(
+      r,
+      "</body>",
+      i
+    );
+  }
+  return /^\s*<!DOCTYPE/i.test(r) ? r : `<!DOCTYPE html>${r}`;
+}, Le = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0
+}) => {
+  const s = e["index.html"] || "", { entryPoints: r, inlineScripts: o } = Ie(s);
+  if (r.length === 0)
+    return { files: e, bundledJS: "" };
+  const c = { ...e };
+  for (const l of o)
+    c[l.id] = l.content;
+  const i = /* @__PURE__ */ new Map(), a = [];
+  for (const l of r) {
+    const m = await Ne({
+      entryPoint: l,
+      files: c,
+      rollup: t,
+      enableSourcemap: n
+    });
+    i.set(l, m), a.push(m);
+  }
+  const u = Ve(
+    c,
+    i,
+    o,
+    !0
+  ), d = a.join(`
+`);
+  return {
+    files: {
+      ...e,
+      "index.html": u
+    },
+    bundledJS: d
+  };
+}, x = !1, ze = (e) => {
+  const t = `<script>${j()}<\/script>`;
+  return e.includes("</head>") ? e.replace(
+    "</head>",
+    `${t}
+</head>`
+  ) : e.includes("</body>") ? e.replace(
+    "</body>",
+    `${t}
+</body>`
+  ) : e + t;
+}, Ae = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0,
+  vizCache: s,
+  vizId: r,
+  slugCache: o,
+  getSvelteCompiler: c
+}) => {
+  try {
+    if (x && console.log(
+      "[build] files:",
+      e ? JSON.stringify(e).substring(0, 100) : void 0
+    ), x && console.log("[build] vizCache:", s), x && console.log("[build] vizId:", r), !e && !s)
+      throw new Error(
+        "Either files or vizCache is required"
+      );
+    if (!e && s && !r)
+      throw new Error(
+        "vizId is required when using vizCache"
+      );
+    if (!e && s && r && (e = X(
+      (await s.get(r))?.files
+    )), !e)
+      throw new Error("Upable to extract viz files");
+    const i = ge(e);
+    if (x && console.log("[build] version:", i), i === "v1")
+      return {
+        html: ze(
+          C(e)
+        ),
+        runtimeVersion: i
+      };
+    if (i === "v2") {
+      if (!t)
+        throw new Error(
+          "Rollup is required for v2 runtime"
+        );
+      return {
+        html: C(
+          await Re({ files: e, rollup: t, enableSourcemap: n })
+        ),
+        runtimeVersion: i
+      };
+    }
+    if (i === "v3") {
+      if (!t)
+        throw new Error(
+          "Rollup is required for v3 runtime"
+        );
+      if (!s && !r) {
+        const a = he(e);
+        r = a.id, s = fe({
+          initialContents: [a],
+          handleCacheMiss: async () => {
+            throw new Error(
+              "Cache miss handler not implemented"
+            );
+          }
+        });
+      }
+      if (!s)
+        throw new Error(
+          "vizCache is required for v3 runtime"
+        );
+      if (!r)
+        throw new Error(
+          "vizId is required for v3 runtime if vizCache is provided"
+        );
+      return await me({
+        files: e,
+        rollup: t,
+        vizCache: s,
+        vizId: r,
+        slugCache: o,
+        getSvelteCompiler: c
+      });
+    }
+    if (i === "v4") {
+      if (!t)
+        throw new Error(
+          "Rollup is required for v4 runtime"
+        );
+      x && console.log("[build] v4Build", {
+        files: e,
+        rollup: t,
+        enableSourcemap: n
+      });
+      const a = await Le({
+        files: e,
+        rollup: t,
+        enableSourcemap: n
+      });
+      return {
+        html: C(a.files),
+        js: a.bundledJS,
+        runtimeVersion: i
+      };
+    }
+    throw new Error(
+      `Unsupported runtime version: ${i}`
+    );
+  } catch (i) {
+    throw i instanceof Error && i.message.indexOf(h) && (i.message = i.message.replace(
+      h,
+      ""
+    )), i;
+  }
+};
+export {
+  fe as a,
+  Ae as b,
+  de as c,
+  ge as d,
+  Ue as e,
+  he as f,
+  We as g,
+  De as s,
+  me as v
+};
+//# sourceMappingURL=build-BT6ouBQg.js.map