@vizhub/runtime 0.5.0 → 0.6.0

package/dist/build-DU4cyBtp.js

@@ -0,0 +1,855 @@
+import { magicSandbox as j } from "magic-sandbox";
+import { isVizId as z, getFileText as k, generateVizId as U, vizFilesToFileCollection as J } from "@vizhub/viz-utils";
+import { transform as V } from "sucrase";
+const jt = () => (Math.random() + "").slice(2);
+function I() {
+  return {
+    name: "sucrase",
+    transform(e, t) {
+      if (!t.match(/\.(?:js|[jt]sx)$/))
+        return null;
+      const n = V(e, {
+        transforms: ["jsx", "typescript"],
+        filePath: t,
+        // For source maps
+        sourceMapOptions: {
+          compiledFilename: "bundle.js"
+        },
+        production: !0
+      });
+      return {
+        code: n.code,
+        map: n.sourceMap
+      };
+    }
+  };
+}
+const T = {
+  dependencies: {},
+  vizhub: {},
+  license: "MIT"
+}, D = !1, x = (e) => {
+  const t = e["package.json"];
+  try {
+    const n = t ? JSON.parse(t) : T;
+    return D && console.log(
+      "[packageJSON] pkg:",
+      JSON.stringify(n, null, 2)
+    ), n;
+  } catch {
+    return T;
+  }
+}, N = (e) => x(e).dependencies || {}, C = (e) => (x(e).vizhub || {}).libraries || {}, R = ({ name: e, version: t }, n, r = "jsdelivr") => {
+  const s = n[e] && n[e].path || "";
+  return r === "jsdelivr" ? `https://cdn.jsdelivr.net/npm/${e}@${t}${s}` : `https://unpkg.com/${e}@${t}${s}`;
+}, B = (e) => {
+  var n;
+  const t = (n = e == null ? void 0 : e.vizhub) == null ? void 0 : n.libraries;
+  return t ? Object.entries(t).reduce(
+    (r, [s, o]) => (o.global && (r[s] = o.global), r),
+    {}
+  ) : {};
+}, A = {
+  d3: "d3",
+  react: "React",
+  "react-dom": "ReactDOM"
+}, W = (e) => {
+  const t = B(e);
+  return {
+    ...A,
+    ...t
+  };
+}, v = (e) => {
+  const [t, ...n] = e.split("/"), r = n.join("/");
+  return { vizId: t, fileName: r };
+}, q = `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 };`, Y = (e) => (
+  // str.replace(/`/g, '\\`');
+  e.replace(/\\/g, "\\\\").replace(/`/g, "\\`")
+), _ = () => ({
+  name: "transformDSV",
+  // `id` here is of the form
+  // `{vizId}/{fileName}`
+  transform: async (e, t) => {
+    const { fileName: n } = v(t), r = n.endsWith(".csv"), s = n.endsWith(".tsv");
+    if (r || s)
+      return {
+        code: `
+            ${q}
+            const data = ${r ? "csvParse" : "tsvParse"}(\`${Y(e)}\`);
+            export default data;
+          `,
+        map: { mappings: "" }
+      };
+  }
+}), G = (e) => {
+  const t = /^@([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_-]+)$/, n = e.match(t);
+  return n ? {
+    userName: n[1],
+    idOrSlug: n[2]
+  } : null;
+}, H = ({
+  vizId: e,
+  slugCache: t
+}) => ({
+  name: "vizResolve",
+  resolveId: async (n, r) => {
+    if (n.startsWith("./") && !(r != null && r.startsWith("https://"))) {
+      let o = n.substring(2);
+      if (!o.endsWith(".js") && !o.endsWith(".css") && !o.endsWith(".csv") && !o.endsWith(".svelte") && (o += ".js"), r) {
+        const {
+          vizId: i,
+          fileName: c
+        } = v(r), a = c.split("/").slice(0, -1).join("/"), l = a ? `${a}/${o}` : o;
+        return `${i}/${l}`;
+      }
+      return e + "/" + o;
+    }
+    const s = G(n);
+    if (s) {
+      let o;
+      if (z(s.idOrSlug))
+        o = s.idOrSlug;
+      else {
+        if (!t)
+          throw new Error(
+            "slugCache is required to import by slug in v3 runtime"
+          );
+        o = await t.get(
+          `${s.userName}/${s.idOrSlug}`
+        );
+      }
+      return o + "/index.js";
+    }
+  }
+}), Q = ({
+  vizCache: e,
+  trackCSSImport: t
+}) => ({
+  name: "vizLoad",
+  // `id` here is of the form
+  // `{vizId}/{fileName}`
+  load: async (n) => {
+    const { vizId: r, fileName: s } = v(n);
+    if (s.endsWith(".css"))
+      return t(n), "";
+    const o = await e.get(r), i = k(o, s);
+    if (i === null)
+      throw new Error(
+        `Imported file "${s}" not found.`
+      );
+    return i;
+  }
+}), M = /* @__PURE__ */ new Map();
+let S;
+const w = "https://cdn.jsdelivr.net/npm/svelte@4.2.9", St = `${w}/compiler.cjs`, Z = ({
+  getSvelteCompiler: e
+}) => ({
+  name: "transformSvelte",
+  load: async (t) => {
+    if (!t.startsWith(w))
+      return;
+    const n = M.get(t);
+    if (n) return n;
+    const r = await fetch(t).then(
+      (s) => s.text()
+    );
+    return M.set(t, r), r;
+  },
+  // From https://github.com/sveltejs/sites/blob/master/packages/repl/src/lib/workers/bundler/index.js#L255C2-L271C5
+  resolveId: async (t, n) => {
+    if (t === "svelte")
+      return `${w}/src/runtime/index.js`;
+    if (t.startsWith("svelte/")) {
+      const r = t.slice(7);
+      return `${w}/src/runtime/${r}/index.js`;
+    }
+    if (/^https?:/.test(t)) return t;
+    if (t.startsWith(".") && n && n.startsWith(w)) {
+      const r = new URL(t, n).href;
+      return new URL(t, n).href, r;
+    }
+  },
+  transform: async (t, n) => {
+    const { fileName: r } = v(n);
+    if (r.endsWith(".svelte")) {
+      if (!S) {
+        if (!e)
+          throw new Error("Svelte compiler not available");
+        S = await e();
+      }
+      return S(t, {
+        filename: r,
+        hydratable: !0
+      }).js;
+    }
+  }
+}), K = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0,
+  vizCache: r,
+  vizId: s,
+  slugCache: o,
+  getSvelteCompiler: i
+}) => {
+  const c = /* @__PURE__ */ new Set(), a = (u) => {
+    c.add(u);
+  };
+  if (!e["index.js"])
+    throw new Error("Missing index.js");
+  const d = {
+    input: "./index.js",
+    plugins: [
+      ...s ? [H({ vizId: s, slugCache: o })] : [],
+      _(),
+      I(),
+      Z({ getSvelteCompiler: i }),
+      ...r ? [Q({ vizCache: r, trackCSSImport: a })] : []
+    ],
+    onwarn(u, h) {
+      u.code !== "UNRESOLVED_IMPORT" && h(u);
+    }
+  }, p = {
+    format: "umd",
+    name: "Viz",
+    sourcemap: !!n,
+    compact: !0
+  }, f = x(e);
+  if (f) {
+    const u = W(f);
+    u && (d.external = Object.keys(u), p.globals = u);
+  }
+  const g = await t(d), { output: m } = await g.generate(p);
+  return {
+    src: m[0].code,
+    cssFiles: Array.from(c)
+  };
+};
+function X() {
+  return Math.random().toString().slice(2, 7);
+}
+const tt = ({
+  cdn: e,
+  src: t,
+  styles: n
+}) => {
+  const s = `viz-container-${X()}`;
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">${e}${n}
+  <style>
+    body {
+      margin: 0;
+      overflow: hidden;
+    }
+    #${s} {
+      height: 100vh;
+    }
+  </style>
+</head>
+<body>
+  <div id="${s}"></div>
+  <script id="injected-script">${t}<\/script>
+  <script>
+    (() => {
+      let cleanup;
+      const render = () => {
+        const container = document.getElementById('${s}');
+        typeof cleanup === 'function' && cleanup();
+        cleanup = 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>`;
+}, et = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0,
+  vizCache: r,
+  vizId: s,
+  slugCache: o,
+  getSvelteCompiler: i
+}) => {
+  const { src: c, cssFiles: a } = await K({
+    files: e,
+    rollup: t,
+    enableSourcemap: n,
+    vizCache: r,
+    vizId: s,
+    slugCache: o,
+    getSvelteCompiler: i
+  });
+  let l = [];
+  if (a.length > 0)
+    for (let m = 0; m < a.length; m++) {
+      const u = a[m], { vizId: h, fileName: y } = v(u), b = await r.get(h), E = k(b, y);
+      E && l.push(E);
+    }
+  const d = l.join(`
+`), p = `
+    <style id="injected-style">${d}</style>`;
+  let f = "";
+  const g = Object.entries(
+    N(e)
+  );
+  if (g.length > 0) {
+    const m = C(e);
+    f = g.map(([u, h], y) => {
+      const b = R(
+        { name: u, version: h },
+        m
+      );
+      return `${y > 0 ? "    " : `
+    `}<script src="${b}"><\/script>`;
+    }).join("");
+  }
+  return {
+    html: tt({ cdn: f, src: c, styles: p }),
+    css: d,
+    js: c
+  };
+}, nt = ({
+  initialContents: e,
+  handleCacheMiss: t
+}) => {
+  const n = new Map(
+    e.map((i) => [i.id, i])
+  );
+  return { get: async (i) => {
+    const c = n.get(i);
+    if (c !== void 0)
+      return c;
+    if (!t)
+      throw new Error(
+        `Unresolved import from vizId ${i}, cache miss handler not provided.`
+      );
+    const a = await t(i);
+    if (a)
+      return n.set(i, a), a;
+    throw new Error(
+      `Unresolved import from vizId ${i}`
+    );
+  }, set: (i) => {
+    n.set(i.id, i);
+  }, invalidate: (i) => {
+    n.delete(i);
+  } };
+}, $t = ({
+  initialMappings: e = {},
+  handleCacheMiss: t
+}) => {
+  const n = new Map(
+    Object.entries(e)
+  );
+  return { get: async (i) => {
+    const c = n.get(i);
+    if (c !== void 0)
+      return c;
+    if (!t)
+      throw new Error(
+        `Unresolved slug ${i}, cache miss handler not provided.`
+      );
+    const a = await t(i);
+    if (a)
+      return n.set(i, a), a;
+    throw new Error(`Unresolved slug ${i}`);
+  }, set: (i, c) => {
+    n.set(i, c);
+  }, invalidate: (i) => {
+    n.delete(i);
+  } };
+}, rt = (e, t = "Sample Content for Exporting") => {
+  const n = U(), r = {};
+  return Object.entries(e).forEach(
+    ([s, o]) => {
+      const i = Math.floor(
+        Math.random() * 1e7
+      ).toString();
+      r[i] = {
+        name: s,
+        text: o
+      };
+    }
+  ), {
+    id: n,
+    files: r,
+    title: t
+  };
+}, st = (e) => {
+  if (Object.keys(e).length === 0)
+    return null;
+  const t = "index.html" in e, n = "index.js" in e, r = "index.jsx" in e;
+  return t ? e["index.html"].includes('type="module"') ? "v4" : n || r ? "v2" : "v1" : !t && n ? "v3" : null;
+}, $ = (e, t) => new RegExp(`<${t}\\b`, "i").test(e) && new RegExp(`</${t}>`, "i").test(e), ot = (e) => {
+  const t = e.trim();
+  return $(t, "html") && $(t, "head") && $(t, "body") ? t : `<html><head></head><body>${t}</body></html>`;
+}, it = (e, t) => e.replace(
+  new RegExp(
+    `<script[^>]*src=["'][^"']*${t.source}[^"']*["'][^>]*>\\s*<\/script>`,
+    "gi"
+  ),
+  ""
+), P = (e, t, n) => e.replace(
+  new RegExp(t, "i"),
+  `${n}${t}`
+), ct = (e, t) => {
+  let n = ot(e);
+  const r = Object.entries(N(t));
+  if (r.length) {
+    const o = C(t);
+    r.forEach(([c]) => {
+      n = it(n, new RegExp(`${c}@`));
+    });
+    const i = r.map(
+      ([c, a]) => R({ name: c, version: a }, o)
+    ).map((c) => `<script src="${c}"><\/script>`).join(`
+`);
+    n = P(
+      n,
+      "</head>",
+      i + `
+`
+    );
+  }
+  if (t["bundle.js"] !== void 0 || t["index.js"] !== void 0) {
+    const o = '<script src="bundle.js"><\/script>', i = /<script\b[^>]*\bsrc=["']bundle\.js["'][^>]*>\s*<\/script>/gi, c = [...n.matchAll(i)];
+    c.length === 1 && (() => {
+      const l = c[0].index ?? -1;
+      if (l === -1) return !1;
+      const d = n.search(/<body\b[^>]*>/i), p = n.search(/<\/body>/i);
+      return d !== -1 && p !== -1 && l > d && l < p;
+    })() || (n = n.replace(i, ""), n = P(n, "</body>", o));
+  }
+  return /^\s*<!DOCTYPE/i.test(n) ? n : `<!DOCTYPE html>${n}`;
+}, at = (e) => {
+  const t = e["index.html"];
+  return !t && !e["index.js"] && !e["bundle.js"] ? "" : ct(t || "<!DOCTYPE html><html><head></head><body></body></html>", e);
+}, F = (e) => {
+  let t = e.replace(/^\.\//, "");
+  return t = t.replace(/\/+/g, "/"), t = t.replace(/\/$/, ""), t;
+}, lt = (e, t) => {
+  const n = e.includes("/") ? e.slice(0, e.lastIndexOf("/")) : "", r = t.split("/"), s = n ? n.split("/") : [];
+  for (const o of r)
+    o === ".." ? s.pop() : o !== "." && o !== "" && s.push(o);
+  return s.join("/");
+}, L = (e) => ({
+  name: "virtual-file-system",
+  resolveId(t, n) {
+    if (t.startsWith("./") || t.startsWith("../")) {
+      const s = F(n ? lt(n, t) : t);
+      if (e[s])
+        return s;
+      const o = [".js", ".jsx", ".ts", ".tsx"];
+      for (const i of o) {
+        const c = s + i;
+        if (e[c])
+          return c;
+      }
+    }
+    if (e[t])
+      return t;
+    const r = [".js", ".jsx", ".ts", ".tsx"];
+    for (const s of r) {
+      const o = t + s;
+      if (e[o])
+        return o;
+    }
+    return null;
+  },
+  load(t) {
+    return e[t] ? e[t] : null;
+  }
+}), ut = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0
+}) => {
+  if (!e["index.js"])
+    throw new Error("Missing index.js");
+  const s = {
+    input: "./index.js",
+    plugins: [L(e), I()],
+    onwarn(l, d) {
+      l.code !== "UNRESOLVED_IMPORT" && d(l);
+    }
+  }, o = {
+    format: "iife",
+    sourcemap: n
+  }, i = x(e);
+  if (i) {
+    const l = W(i);
+    l && (s.external = Object.keys(l), o.globals = l);
+  }
+  const c = await t(s), { output: a } = await c.generate(o);
+  return a[0].code;
+}, dt = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n
+}) => ({
+  ...e,
+  "bundle.js": await ut({
+    files: e,
+    rollup: t,
+    enableSourcemap: n
+  }),
+  "index.html": at(e)
+}), pt = (e) => {
+  const t = [], n = /<script\b([^>]*)>[\s\S]*?<\/script>/gi;
+  let r;
+  for (; (r = n.exec(e)) !== null; ) {
+    const s = r[1];
+    if (!/\btype\s*=\s*["']module["']/i.test(s))
+      continue;
+    const o = s.match(
+      /\bsrc\s*=\s*["']([^"']+)["']/i
+    );
+    o && t.push(o[1]);
+  }
+  return t;
+}, mt = async ({
+  entryPoint: e,
+  files: t,
+  rollup: n,
+  enableSourcemap: r = !0
+}) => {
+  const s = {
+    input: `./${e}`,
+    plugins: [L(t), I()],
+    external: (c) => t[c] ? !1 : !c.startsWith("./"),
+    onwarn(c, a) {
+      a(c);
+    }
+  }, o = await n(s), { output: i } = await o.generate({
+    format: "es",
+    sourcemap: r
+  });
+  return i[0].code;
+}, O = (e, t) => new RegExp(`<${t}\\b`, "i").test(e) && new RegExp(`</${t}>`, "i").test(e), ft = (e) => {
+  const t = e.trim();
+  return O(t, "html") && O(t, "head") && O(t, "body") ? t : `<html><head></head><body>${t}</body></html>`;
+}, ht = (e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), wt = (e, t, n) => e.replace(
+  new RegExp(t, "i"),
+  `${n}${t}`
+), vt = (e) => {
+  const t = N(e);
+  if (Object.keys(t).length === 0) return null;
+  const n = C(e), r = {};
+  for (const [s, o] of Object.entries(t))
+    r[s] = R(
+      { name: s, version: o },
+      n
+    );
+  return JSON.stringify({ imports: r }, null, 2);
+}, gt = (e, t) => {
+  if (!e["index.html"]) return "";
+  let n = ft(e["index.html"]);
+  t.forEach((s, o) => {
+    const i = new RegExp(
+      `<script\\b[^>]*\\bsrc=["']${ht(o)}["'][^>]*>[^<]*<\/script>`,
+      "gi"
+    );
+    n = n.replace(
+      i,
+      `<script type="module">
+${s}
+<\/script>`
+    );
+  });
+  const r = vt(e);
+  if (r && !/<script\b[^>]*type=["']importmap["'][^>]*>/i.test(
+    n
+  )) {
+    const o = `<script type="importmap">
+${r}
+<\/script>
+`;
+    n = wt(
+      n,
+      "</head>",
+      o
+    );
+  }
+  return /^\s*<!DOCTYPE/i.test(n) ? n : `<!DOCTYPE html>${n}`;
+}, xt = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0
+}) => {
+  const r = e["index.html"] || "", s = pt(r);
+  if (s.length === 0)
+    return e;
+  const o = /* @__PURE__ */ new Map();
+  for (const c of s) {
+    const a = await mt({
+      entryPoint: c,
+      files: e,
+      rollup: t,
+      enableSourcemap: n
+    });
+    o.set(c, a);
+  }
+  const i = gt(e, o);
+  return {
+    ...e,
+    "index.html": i
+  };
+}, Ot = async ({
+  files: e,
+  rollup: t,
+  enableSourcemap: n = !0,
+  vizCache: r,
+  vizId: s,
+  slugCache: o,
+  getSvelteCompiler: i
+}) => {
+  var a;
+  if (!e && !r)
+    throw new Error("Either files or vizCache is required");
+  if (!e && r && !s)
+    throw new Error(
+      "vizId is required when using vizCache"
+    );
+  if (!e && r && s && (e = J(
+    (a = await r.get(s)) == null ? void 0 : a.files
+  )), !e)
+    throw new Error("Upable to extract viz files");
+  const c = st(e);
+  if (c === "v1")
+    return {
+      html: j(e)
+    };
+  if (c === "v2") {
+    if (!t)
+      throw new Error("Rollup is required for v2 runtime");
+    return {
+      html: j(
+        await dt({ files: e, rollup: t, enableSourcemap: n })
+      )
+    };
+  }
+  if (c === "v3") {
+    if (!t)
+      throw new Error("Rollup is required for v3 runtime");
+    if (!r && !s) {
+      const l = rt(e);
+      s = l.id, r = nt({
+        initialContents: [l],
+        handleCacheMiss: async () => {
+          throw new Error(
+            "Cache miss handler not implemented"
+          );
+        }
+      });
+    }
+    if (!r)
+      throw new Error(
+        "vizCache is required for v3 runtime"
+      );
+    if (!s)
+      throw new Error("vizId is required for v3 runtime");
+    return await et({
+      files: e,
+      rollup: t,
+      vizCache: r,
+      vizId: s,
+      slugCache: o,
+      getSvelteCompiler: i
+    });
+  }
+  if (c === "v4") {
+    if (!t)
+      throw new Error("Rollup is required for v4 runtime");
+    return {
+      html: j(
+        await xt({ files: e, rollup: t, enableSourcemap: n })
+      )
+    };
+  }
+  throw new Error(
+    `Unsupported runtime version: ${c}`
+  );
+};
+export {
+  nt as a,
+  Ot as b,
+  K as c,
+  $t as d,
+  rt as e,
+  jt as g,
+  St as s,
+  et as v
+};
+//# sourceMappingURL=build-DU4cyBtp.js.map