@vizhub/runtime 3.0.0 → 4.0.1

package/dist/build-C3ij8Dz4.js

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