repl-sdk 1.0.0 → 1.0.2

package/dist/index-CUWCqMoD.js

@@ -1,2133 +0,0 @@
-import { wrap } from "comlink";
-import { exports } from "resolve.exports";
-import { resolve as resolve$2 } from "resolve.imports";
-const types = {
-  "application/andrew-inset": ["ez"],
-  "application/appinstaller": ["appinstaller"],
-  "application/applixware": ["aw"],
-  "application/appx": ["appx"],
-  "application/appxbundle": ["appxbundle"],
-  "application/atom+xml": ["atom"],
-  "application/atomcat+xml": ["atomcat"],
-  "application/atomdeleted+xml": ["atomdeleted"],
-  "application/atomsvc+xml": ["atomsvc"],
-  "application/atsc-dwd+xml": ["dwd"],
-  "application/atsc-held+xml": ["held"],
-  "application/atsc-rsat+xml": ["rsat"],
-  "application/automationml-aml+xml": ["aml"],
-  "application/automationml-amlx+zip": ["amlx"],
-  "application/bdoc": ["bdoc"],
-  "application/calendar+xml": ["xcs"],
-  "application/ccxml+xml": ["ccxml"],
-  "application/cdfx+xml": ["cdfx"],
-  "application/cdmi-capability": ["cdmia"],
-  "application/cdmi-container": ["cdmic"],
-  "application/cdmi-domain": ["cdmid"],
-  "application/cdmi-object": ["cdmio"],
-  "application/cdmi-queue": ["cdmiq"],
-  "application/cpl+xml": ["cpl"],
-  "application/cu-seeme": ["cu"],
-  "application/cwl": ["cwl"],
-  "application/dash+xml": ["mpd"],
-  "application/dash-patch+xml": ["mpp"],
-  "application/davmount+xml": ["davmount"],
-  "application/dicom": ["dcm"],
-  "application/docbook+xml": ["dbk"],
-  "application/dssc+der": ["dssc"],
-  "application/dssc+xml": ["xdssc"],
-  "application/ecmascript": ["ecma"],
-  "application/emma+xml": ["emma"],
-  "application/emotionml+xml": ["emotionml"],
-  "application/epub+zip": ["epub"],
-  "application/exi": ["exi"],
-  "application/express": ["exp"],
-  "application/fdf": ["fdf"],
-  "application/fdt+xml": ["fdt"],
-  "application/font-tdpfr": ["pfr"],
-  "application/geo+json": ["geojson"],
-  "application/gml+xml": ["gml"],
-  "application/gpx+xml": ["gpx"],
-  "application/gxf": ["gxf"],
-  "application/gzip": ["gz"],
-  "application/hjson": ["hjson"],
-  "application/hyperstudio": ["stk"],
-  "application/inkml+xml": ["ink", "inkml"],
-  "application/ipfix": ["ipfix"],
-  "application/its+xml": ["its"],
-  "application/java-archive": ["jar", "war", "ear"],
-  "application/java-serialized-object": ["ser"],
-  "application/java-vm": ["class"],
-  "application/javascript": ["*js"],
-  "application/json": ["json", "map"],
-  "application/json5": ["json5"],
-  "application/jsonml+json": ["jsonml"],
-  "application/ld+json": ["jsonld"],
-  "application/lgr+xml": ["lgr"],
-  "application/lost+xml": ["lostxml"],
-  "application/mac-binhex40": ["hqx"],
-  "application/mac-compactpro": ["cpt"],
-  "application/mads+xml": ["mads"],
-  "application/manifest+json": ["webmanifest"],
-  "application/marc": ["mrc"],
-  "application/marcxml+xml": ["mrcx"],
-  "application/mathematica": ["ma", "nb", "mb"],
-  "application/mathml+xml": ["mathml"],
-  "application/mbox": ["mbox"],
-  "application/media-policy-dataset+xml": ["mpf"],
-  "application/mediaservercontrol+xml": ["mscml"],
-  "application/metalink+xml": ["metalink"],
-  "application/metalink4+xml": ["meta4"],
-  "application/mets+xml": ["mets"],
-  "application/mmt-aei+xml": ["maei"],
-  "application/mmt-usd+xml": ["musd"],
-  "application/mods+xml": ["mods"],
-  "application/mp21": ["m21", "mp21"],
-  "application/mp4": ["*mp4", "*mpg4", "mp4s", "m4p"],
-  "application/msix": ["msix"],
-  "application/msixbundle": ["msixbundle"],
-  "application/msword": ["doc", "dot"],
-  "application/mxf": ["mxf"],
-  "application/n-quads": ["nq"],
-  "application/n-triples": ["nt"],
-  "application/node": ["cjs"],
-  "application/octet-stream": [
-    "bin",
-    "dms",
-    "lrf",
-    "mar",
-    "so",
-    "dist",
-    "distz",
-    "pkg",
-    "bpk",
-    "dump",
-    "elc",
-    "deploy",
-    "exe",
-    "dll",
-    "deb",
-    "dmg",
-    "iso",
-    "img",
-    "msi",
-    "msp",
-    "msm",
-    "buffer"
-  ],
-  "application/oda": ["oda"],
-  "application/oebps-package+xml": ["opf"],
-  "application/ogg": ["ogx"],
-  "application/omdoc+xml": ["omdoc"],
-  "application/onenote": [
-    "onetoc",
-    "onetoc2",
-    "onetmp",
-    "onepkg",
-    "one",
-    "onea"
-  ],
-  "application/oxps": ["oxps"],
-  "application/p2p-overlay+xml": ["relo"],
-  "application/patch-ops-error+xml": ["xer"],
-  "application/pdf": ["pdf"],
-  "application/pgp-encrypted": ["pgp"],
-  "application/pgp-keys": ["asc"],
-  "application/pgp-signature": ["sig", "*asc"],
-  "application/pics-rules": ["prf"],
-  "application/pkcs10": ["p10"],
-  "application/pkcs7-mime": ["p7m", "p7c"],
-  "application/pkcs7-signature": ["p7s"],
-  "application/pkcs8": ["p8"],
-  "application/pkix-attr-cert": ["ac"],
-  "application/pkix-cert": ["cer"],
-  "application/pkix-crl": ["crl"],
-  "application/pkix-pkipath": ["pkipath"],
-  "application/pkixcmp": ["pki"],
-  "application/pls+xml": ["pls"],
-  "application/postscript": ["ai", "eps", "ps"],
-  "application/provenance+xml": ["provx"],
-  "application/pskc+xml": ["pskcxml"],
-  "application/raml+yaml": ["raml"],
-  "application/rdf+xml": ["rdf", "owl"],
-  "application/reginfo+xml": ["rif"],
-  "application/relax-ng-compact-syntax": ["rnc"],
-  "application/resource-lists+xml": ["rl"],
-  "application/resource-lists-diff+xml": ["rld"],
-  "application/rls-services+xml": ["rs"],
-  "application/route-apd+xml": ["rapd"],
-  "application/route-s-tsid+xml": ["sls"],
-  "application/route-usd+xml": ["rusd"],
-  "application/rpki-ghostbusters": ["gbr"],
-  "application/rpki-manifest": ["mft"],
-  "application/rpki-roa": ["roa"],
-  "application/rsd+xml": ["rsd"],
-  "application/rss+xml": ["rss"],
-  "application/rtf": ["rtf"],
-  "application/sbml+xml": ["sbml"],
-  "application/scvp-cv-request": ["scq"],
-  "application/scvp-cv-response": ["scs"],
-  "application/scvp-vp-request": ["spq"],
-  "application/scvp-vp-response": ["spp"],
-  "application/sdp": ["sdp"],
-  "application/senml+xml": ["senmlx"],
-  "application/sensml+xml": ["sensmlx"],
-  "application/set-payment-initiation": ["setpay"],
-  "application/set-registration-initiation": ["setreg"],
-  "application/shf+xml": ["shf"],
-  "application/sieve": ["siv", "sieve"],
-  "application/smil+xml": ["smi", "smil"],
-  "application/sparql-query": ["rq"],
-  "application/sparql-results+xml": ["srx"],
-  "application/sql": ["sql"],
-  "application/srgs": ["gram"],
-  "application/srgs+xml": ["grxml"],
-  "application/sru+xml": ["sru"],
-  "application/ssdl+xml": ["ssdl"],
-  "application/ssml+xml": ["ssml"],
-  "application/swid+xml": ["swidtag"],
-  "application/tei+xml": ["tei", "teicorpus"],
-  "application/thraud+xml": ["tfi"],
-  "application/timestamped-data": ["tsd"],
-  "application/toml": ["toml"],
-  "application/trig": ["trig"],
-  "application/ttml+xml": ["ttml"],
-  "application/ubjson": ["ubj"],
-  "application/urc-ressheet+xml": ["rsheet"],
-  "application/urc-targetdesc+xml": ["td"],
-  "application/voicexml+xml": ["vxml"],
-  "application/wasm": ["wasm"],
-  "application/watcherinfo+xml": ["wif"],
-  "application/widget": ["wgt"],
-  "application/winhlp": ["hlp"],
-  "application/wsdl+xml": ["wsdl"],
-  "application/wspolicy+xml": ["wspolicy"],
-  "application/xaml+xml": ["xaml"],
-  "application/xcap-att+xml": ["xav"],
-  "application/xcap-caps+xml": ["xca"],
-  "application/xcap-diff+xml": ["xdf"],
-  "application/xcap-el+xml": ["xel"],
-  "application/xcap-ns+xml": ["xns"],
-  "application/xenc+xml": ["xenc"],
-  "application/xfdf": ["xfdf"],
-  "application/xhtml+xml": ["xhtml", "xht"],
-  "application/xliff+xml": ["xlf"],
-  "application/xml": ["xml", "xsl", "xsd", "rng"],
-  "application/xml-dtd": ["dtd"],
-  "application/xop+xml": ["xop"],
-  "application/xproc+xml": ["xpl"],
-  "application/xslt+xml": ["*xsl", "xslt"],
-  "application/xspf+xml": ["xspf"],
-  "application/xv+xml": ["mxml", "xhvml", "xvml", "xvm"],
-  "application/yang": ["yang"],
-  "application/yin+xml": ["yin"],
-  "application/zip": ["zip"],
-  "application/zip+dotlottie": ["lottie"],
-  "audio/3gpp": ["*3gpp"],
-  "audio/aac": ["adts", "aac"],
-  "audio/adpcm": ["adp"],
-  "audio/amr": ["amr"],
-  "audio/basic": ["au", "snd"],
-  "audio/midi": ["mid", "midi", "kar", "rmi"],
-  "audio/mobile-xmf": ["mxmf"],
-  "audio/mp3": ["*mp3"],
-  "audio/mp4": ["m4a", "mp4a", "m4b"],
-  "audio/mpeg": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"],
-  "audio/ogg": ["oga", "ogg", "spx", "opus"],
-  "audio/s3m": ["s3m"],
-  "audio/silk": ["sil"],
-  "audio/wav": ["wav"],
-  "audio/wave": ["*wav"],
-  "audio/webm": ["weba"],
-  "audio/xm": ["xm"],
-  "font/collection": ["ttc"],
-  "font/otf": ["otf"],
-  "font/ttf": ["ttf"],
-  "font/woff": ["woff"],
-  "font/woff2": ["woff2"],
-  "image/aces": ["exr"],
-  "image/apng": ["apng"],
-  "image/avci": ["avci"],
-  "image/avcs": ["avcs"],
-  "image/avif": ["avif"],
-  "image/bmp": ["bmp", "dib"],
-  "image/cgm": ["cgm"],
-  "image/dicom-rle": ["drle"],
-  "image/dpx": ["dpx"],
-  "image/emf": ["emf"],
-  "image/fits": ["fits"],
-  "image/g3fax": ["g3"],
-  "image/gif": ["gif"],
-  "image/heic": ["heic"],
-  "image/heic-sequence": ["heics"],
-  "image/heif": ["heif"],
-  "image/heif-sequence": ["heifs"],
-  "image/hej2k": ["hej2"],
-  "image/ief": ["ief"],
-  "image/jaii": ["jaii"],
-  "image/jais": ["jais"],
-  "image/jls": ["jls"],
-  "image/jp2": ["jp2", "jpg2"],
-  "image/jpeg": ["jpg", "jpeg", "jpe"],
-  "image/jph": ["jph"],
-  "image/jphc": ["jhc"],
-  "image/jpm": ["jpm", "jpgm"],
-  "image/jpx": ["jpx", "jpf"],
-  "image/jxl": ["jxl"],
-  "image/jxr": ["jxr"],
-  "image/jxra": ["jxra"],
-  "image/jxrs": ["jxrs"],
-  "image/jxs": ["jxs"],
-  "image/jxsc": ["jxsc"],
-  "image/jxsi": ["jxsi"],
-  "image/jxss": ["jxss"],
-  "image/ktx": ["ktx"],
-  "image/ktx2": ["ktx2"],
-  "image/pjpeg": ["jfif"],
-  "image/png": ["png"],
-  "image/sgi": ["sgi"],
-  "image/svg+xml": ["svg", "svgz"],
-  "image/t38": ["t38"],
-  "image/tiff": ["tif", "tiff"],
-  "image/tiff-fx": ["tfx"],
-  "image/webp": ["webp"],
-  "image/wmf": ["wmf"],
-  "message/disposition-notification": ["disposition-notification"],
-  "message/global": ["u8msg"],
-  "message/global-delivery-status": ["u8dsn"],
-  "message/global-disposition-notification": ["u8mdn"],
-  "message/global-headers": ["u8hdr"],
-  "message/rfc822": ["eml", "mime", "mht", "mhtml"],
-  "model/3mf": ["3mf"],
-  "model/gltf+json": ["gltf"],
-  "model/gltf-binary": ["glb"],
-  "model/iges": ["igs", "iges"],
-  "model/jt": ["jt"],
-  "model/mesh": ["msh", "mesh", "silo"],
-  "model/mtl": ["mtl"],
-  "model/obj": ["obj"],
-  "model/prc": ["prc"],
-  "model/step": ["step", "stp", "stpnc", "p21", "210"],
-  "model/step+xml": ["stpx"],
-  "model/step+zip": ["stpz"],
-  "model/step-xml+zip": ["stpxz"],
-  "model/stl": ["stl"],
-  "model/u3d": ["u3d"],
-  "model/vrml": ["wrl", "vrml"],
-  "model/x3d+binary": ["*x3db", "x3dbz"],
-  "model/x3d+fastinfoset": ["x3db"],
-  "model/x3d+vrml": ["*x3dv", "x3dvz"],
-  "model/x3d+xml": ["x3d", "x3dz"],
-  "model/x3d-vrml": ["x3dv"],
-  "text/cache-manifest": ["appcache", "manifest"],
-  "text/calendar": ["ics", "ifb"],
-  "text/coffeescript": ["coffee", "litcoffee"],
-  "text/css": ["css"],
-  "text/csv": ["csv"],
-  "text/html": ["html", "htm", "shtml"],
-  "text/jade": ["jade"],
-  "text/javascript": ["js", "mjs"],
-  "text/jsx": ["jsx"],
-  "text/less": ["less"],
-  "text/markdown": ["md", "markdown"],
-  "text/mathml": ["mml"],
-  "text/mdx": ["mdx"],
-  "text/n3": ["n3"],
-  "text/plain": ["txt", "text", "conf", "def", "list", "log", "in", "ini"],
-  "text/richtext": ["rtx"],
-  "text/rtf": ["*rtf"],
-  "text/sgml": ["sgml", "sgm"],
-  "text/shex": ["shex"],
-  "text/slim": ["slim", "slm"],
-  "text/spdx": ["spdx"],
-  "text/stylus": ["stylus", "styl"],
-  "text/tab-separated-values": ["tsv"],
-  "text/troff": ["t", "tr", "roff", "man", "me", "ms"],
-  "text/turtle": ["ttl"],
-  "text/uri-list": ["uri", "uris", "urls"],
-  "text/vcard": ["vcard"],
-  "text/vtt": ["vtt"],
-  "text/wgsl": ["wgsl"],
-  "text/xml": ["*xml"],
-  "text/yaml": ["yaml", "yml"],
-  "video/3gpp": ["3gp", "3gpp"],
-  "video/3gpp2": ["3g2"],
-  "video/h261": ["h261"],
-  "video/h263": ["h263"],
-  "video/h264": ["h264"],
-  "video/iso.segment": ["m4s"],
-  "video/jpeg": ["jpgv"],
-  "video/jpm": ["*jpm", "*jpgm"],
-  "video/mj2": ["mj2", "mjp2"],
-  "video/mp2t": ["ts", "m2t", "m2ts", "mts"],
-  "video/mp4": ["mp4", "mp4v", "mpg4"],
-  "video/mpeg": ["mpeg", "mpg", "mpe", "m1v", "m2v"],
-  "video/ogg": ["ogv"],
-  "video/quicktime": ["qt", "mov"],
-  "video/webm": ["webm"]
-};
-Object.freeze(types);
-var __classPrivateFieldGet = function(receiver, state, kind, f) {
-  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Mime_extensionToType, _Mime_typeToExtension, _Mime_typeToExtensions;
-class Mime {
-  constructor(...args) {
-    _Mime_extensionToType.set(this, /* @__PURE__ */ new Map());
-    _Mime_typeToExtension.set(this, /* @__PURE__ */ new Map());
-    _Mime_typeToExtensions.set(this, /* @__PURE__ */ new Map());
-    for (const arg of args) {
-      this.define(arg);
-    }
-  }
-  define(typeMap, force = false) {
-    for (let [type, extensions] of Object.entries(typeMap)) {
-      type = type.toLowerCase();
-      extensions = extensions.map((ext) => ext.toLowerCase());
-      if (!__classPrivateFieldGet(this, _Mime_typeToExtensions, "f").has(type)) {
-        __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").set(type, /* @__PURE__ */ new Set());
-      }
-      const allExtensions = __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type);
-      let first = true;
-      for (let extension of extensions) {
-        const starred = extension.startsWith("*");
-        extension = starred ? extension.slice(1) : extension;
-        allExtensions?.add(extension);
-        if (first) {
-          __classPrivateFieldGet(this, _Mime_typeToExtension, "f").set(type, extension);
-        }
-        first = false;
-        if (starred)
-          continue;
-        const currentType = __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(extension);
-        if (currentType && currentType != type && !force) {
-          throw new Error(`"${type} -> ${extension}" conflicts with "${currentType} -> ${extension}". Pass \`force=true\` to override this definition.`);
-        }
-        __classPrivateFieldGet(this, _Mime_extensionToType, "f").set(extension, type);
-      }
-    }
-    return this;
-  }
-  getType(path) {
-    if (typeof path !== "string")
-      return null;
-    const last = path.replace(/^.*[/\\]/s, "").toLowerCase();
-    const ext = last.replace(/^.*\./s, "").toLowerCase();
-    const hasPath = last.length < path.length;
-    const hasDot = ext.length < last.length - 1;
-    if (!hasDot && hasPath)
-      return null;
-    return __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(ext) ?? null;
-  }
-  getExtension(type) {
-    if (typeof type !== "string")
-      return null;
-    type = type?.split?.(";")[0];
-    return (type && __classPrivateFieldGet(this, _Mime_typeToExtension, "f").get(type.trim().toLowerCase())) ?? null;
-  }
-  getAllExtensions(type) {
-    if (typeof type !== "string")
-      return null;
-    return __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type.toLowerCase()) ?? null;
-  }
-  _freeze() {
-    this.define = () => {
-      throw new Error("define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances");
-    };
-    Object.freeze(this);
-    for (const extensions of __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").values()) {
-      Object.freeze(extensions);
-    }
-    return this;
-  }
-  _getTestState() {
-    return {
-      types: __classPrivateFieldGet(this, _Mime_extensionToType, "f"),
-      extensions: __classPrivateFieldGet(this, _Mime_typeToExtension, "f")
-    };
-  }
-}
-_Mime_extensionToType = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtension = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtensions = /* @__PURE__ */ new WeakMap();
-const mime = new Mime(types)._freeze();
-function assert(message, test) {
-  if (!test) {
-    throw new Error(message);
-  }
-}
-let i = 0;
-function nextId() {
-  i += 1;
-  return `repl_${i}`;
-}
-const fakeDomain = "repl.sdk";
-const tgzPrefix = "file:///tgz.repl.sdk/";
-const unzippedPrefix = "file:///tgz.repl.sdk/unzipped";
-function prefix_tgz(url) {
-  return `${tgzPrefix}${url}`;
-}
-function isRecord(x) {
-  return typeof x === "object" && x !== null && !Array.isArray(x);
-}
-const secretKey = "__repl-sdk__compiler__";
-const secret = Symbol.for(secretKey);
-function getGlobal() {
-  const global = (
-    /** @type {ExtendedWindow} */
-    globalThis
-  );
-  return global;
-}
-assert(
-  `There is already an instance of repl-sdk, and there can only be one. Make sure that your dependency graph is correct.`,
-  !getGlobal()[secret]
-);
-class Caches {
-  clear() {
-    delete getGlobal()[secret];
-  }
-  /**
-   * Cache of resolved modulePaths to their module "value"
-   *
-   * @type {{ [modulePath: string]: unknown }}
-   */
-  get resolves() {
-    this.#root.resolves ||= {};
-    return this.#root.resolves;
-  }
-  /**
-   * Cache of untarred tarballs
-   *
-   * @type {Map<string, import('./types.ts').UntarredPackage>}
-   */
-  get tarballs() {
-    this.#root.tarballs ||= /* @__PURE__ */ new Map();
-    return this.#root.tarballs;
-  }
-  /**
-   * Cache of request resolutions
-   *
-   * @type {Map<string, ResolveIdValue>}
-   */
-  get resolveId() {
-    this.#root.resolveId ||= /* @__PURE__ */ new Map();
-    return this.#root.resolveId;
-  }
-  /**
-   * Cache of request Key to file content string
-   *
-   * @type {Map<string, { code: string, ext: string }>}
-   */
-  get fileCache() {
-    this.#root.fileCache ||= /* @__PURE__ */ new Map();
-    return this.#root.fileCache;
-  }
-  /**
-   * For any key, store a promise for resolving later
-   *
-   * @type {Map<string, Promise<unknown>>}
-   */
-  get promiseCache() {
-    this.#root.promiseCache ||= /* @__PURE__ */ new Map();
-    return this.#root.promiseCache;
-  }
-  /**
-   * @template Return
-   * @type {(key: string, callback: () => Promise<any>) => Promise<any>}
-   */
-  cachedPromise(key, callback) {
-    const existing = this.promiseCache.get(key);
-    if (existing) {
-      return (
-        /** @type {Promise<Return>} */
-        existing
-      );
-    }
-    const promise = callback();
-    this.promiseCache.set(key, promise);
-    return promise;
-  }
-  get requestCache() {
-    this.#root.requestCache ||= /* @__PURE__ */ new Map();
-    return this.#root.requestCache;
-  }
-  get #root() {
-    const global = getGlobal();
-    global[secret] ||= {};
-    global[secret].caches ||= this;
-    return global[secret];
-  }
-}
-const cache = new Caches();
-const externalPackages = [
-  "@ember/test-helpers",
-  "@ember/string",
-  "@ember/test-waiters",
-  "@ember/render-modifiers",
-  "@glimmer/component"
-];
-function resolve$1(id) {
-  if (id === "@ember/template-compiler/runtime") {
-    return `https://esm.sh/*ember-source/dist/packages/@ember/template-compiler/runtime.js`;
-  }
-  const isExternalEmber = externalPackages.some((name) => id.startsWith(name));
-  if (isExternalEmber) {
-    return `https://esm.sh/*${id}`;
-  }
-  if (id.startsWith("@ember")) {
-    return `https://esm.sh/*ember-source/dist/packages/${id}`;
-  }
-  if (id.startsWith("@glimmer")) {
-    return `https://esm.sh/*ember-source/dist/dependencies/${id}.js`;
-  }
-  if (id.startsWith("@embroider/macros")) {
-    return () => ({
-      // passthrough, we are not doing dead-code-elimination
-      /**
-       * @param {unknown} x
-       */
-      macroCondition: (x) => Boolean(x),
-      // I *could* actually implement this
-      dependencySatisfies: () => true,
-      isDevelopingApp: () => true,
-      getGlobalConfig: () => ({
-        WarpDrive: {
-          debug: false,
-          env: {
-            DEBUG: false,
-            TESTING: false,
-            PRODUCTION: true
-          },
-          activeLogging: false,
-          compatWith: "99.0",
-          features: {},
-          deprecations: {},
-          polyfillUUID: false,
-          includeDataAdapter: false
-        }
-      })
-    });
-  }
-}
-function onUnhandled(e, handle) {
-  if (!e.reason?.message) return;
-  let reason = e.reason.message;
-  if (reason.includes("Stack trace for the update:")) {
-    reason += " (see console)";
-  }
-  handle(reason);
-}
-const gjs = {
-  resolve: resolve$1,
-  onUnhandled,
-  codemirror: {
-    lang: async () => {
-      const { gjs: gjs2 } = await import("codemirror-lang-glimmer-js");
-      return gjs2();
-    }
-  },
-  compiler: async (...args) => {
-    const gjs2 = await import("./gjs-CzFzkEFv.js");
-    return gjs2.compiler(...args);
-  }
-};
-const hbs = {
-  resolve: resolve$1,
-  onUnhandled,
-  codemirror: {
-    lang: async () => {
-      const { glimmer } = await import("codemirror-lang-glimmer");
-      return glimmer();
-    }
-  },
-  compiler: async (...args) => {
-    const hbs2 = await import("./hbs-CuhWjffM.js");
-    return hbs2.compiler(...args);
-  }
-};
-const gmd = {
-  resolve: resolve$1,
-  onUnhandled,
-  codemirror: {
-    lang: async () => {
-      const { glimdown } = await import("codemirror-lang-glimdown");
-      return glimdown();
-    },
-    support: async () => {
-      const { gjs: gjs2 } = await import("codemirror-lang-glimmer-js");
-      return [gjs2().support];
-    }
-  },
-  compiler: async (...args) => {
-    const hbs2 = await import("./gmd-D9OXs2v3.js");
-    return hbs2.compiler(...args);
-  }
-};
-const js = {
-  codemirror: {
-    lang: async () => {
-      const { javascript } = await import("@codemirror/lang-javascript");
-      return javascript();
-    }
-  },
-  compiler: async (config, api) => {
-    return {
-      compile: async (text, options) => {
-        return text;
-      },
-      render: async (element, fun, extra, compiler) => {
-        assert(
-          `js document must have a function for a default export. Instead received: ${typeof fun}`,
-          typeof fun === "function"
-        );
-        await fun(element);
-        compiler.announce("info", "Done");
-      }
-    };
-  }
-};
-function isNotMarkdownLike(lang) {
-  return lang !== "md" && lang !== "gmd" && lang !== "mdx";
-}
-function isPreview(meta) {
-  if (!meta) return false;
-  return meta.includes("preview");
-}
-function isBelow(meta) {
-  if (!meta) return false;
-  return meta.includes("below");
-}
-function buildCodeFenceMetaUtils(api) {
-  const allowedFormats = api.getAllowedFormats().filter(isNotMarkdownLike);
-  function needsLive(lang, flavor) {
-    if (!allowedFormats.includes(lang)) return false;
-    return api.optionsFor(lang, flavor).needsLiveMeta ?? true;
-  }
-  function getFlavorFromMeta(meta, lang) {
-    const flavors = api.getFlavorsFor(lang);
-    const flavor = meta?.trim().split(" ").find((metum) => flavors.includes(metum));
-    return flavor;
-  }
-  function isLive(meta, lang) {
-    const flavor = getFlavorFromMeta(meta, lang);
-    if (!needsLive(lang, flavor)) return true;
-    if (!meta) return false;
-    return meta.includes("live");
-  }
-  return {
-    isPreview,
-    isBelow,
-    isLive,
-    needsLive,
-    allowedFormats,
-    getFlavorFromMeta
-  };
-}
-function filterOptions(options) {
-  if (!isRecord(options)) {
-    return { remarkPlugins: [], rehypePlugins: [] };
-  }
-  return {
-    remarkPlugins: (
-      /** @type {Plugin[]}*/
-      options?.remarkPlugins || []
-    ),
-    rehypePlugins: (
-      /** @type {Plugin[]}*/
-      options?.rehypePlugins || []
-    )
-  };
-}
-const md = {
-  codemirror: {
-    lang: async () => {
-      const { glimdown } = await import("codemirror-lang-glimdown");
-      return glimdown();
-    }
-  },
-  compiler: async (config, api) => {
-    const { isLive, isPreview: isPreview2, needsLive, allowedFormats, isBelow: isBelow2, getFlavorFromMeta } = buildCodeFenceMetaUtils(api);
-    const userOptions = filterOptions(
-      /** @type {Record<string, unknown>} */
-      config.userOptions?.md || config
-    );
-    const { parseMarkdown } = await import(
-      /* @vite-ignore */
-      "./parse-aBKk9rfS.js"
-    );
-    return {
-      compile: async (text, options) => {
-        const compileOptions = filterOptions(options);
-        const result = await parseMarkdown(text, {
-          remarkPlugins: [...userOptions.remarkPlugins, ...compileOptions.remarkPlugins],
-          rehypePlugins: [...userOptions.rehypePlugins, ...compileOptions.rehypePlugins],
-          isLive,
-          isPreview: isPreview2,
-          isBelow: isBelow2,
-          needsLive,
-          ALLOWED_FORMATS: allowedFormats,
-          getFlavorFromMeta
-        });
-        const escaped = result.text.replace(/`/g, "\\`");
-        return { compiled: `export default \`${escaped}\``, ...result };
-      },
-      render: async (element, compiled, extra, compiler) => {
-        element.innerHTML = /** @type {string} */
-        compiled;
-        const destroyables = [];
-        await Promise.all(
-          /** @type {unknown[]} */
-          extra.codeBlocks.map(async (info) => {
-            const infoObj = (
-              /** @type {Record<string, unknown>} */
-              info
-            );
-            if (!api.canCompile(
-              /** @type {string} */
-              infoObj.format,
-              /** @type {string} */
-              infoObj.flavor
-            )) {
-              return;
-            }
-            const flavor = (
-              /** @type {string} */
-              infoObj.flavor
-            );
-            const subRender = await compiler.compile(
-              /** @type {string} */
-              infoObj.format,
-              /** @type {string} */
-              infoObj.code,
-              {
-                ...compiler.optionsFor(
-                  /** @type {string} */
-                  infoObj.format,
-                  flavor
-                ),
-                flavor
-              }
-            );
-            const selector = `#${/** @type {string} */
-            infoObj.placeholderId}`;
-            const target = element.querySelector(selector);
-            assert(
-              `Could not find placeholder / target element (using selector: \`${selector}\`). Could not render ${/** @type {string} */
-              infoObj.format} block.`,
-              target
-            );
-            destroyables.push(subRender.destroy);
-            target.appendChild(subRender.element);
-          })
-        );
-        compiler.announce("info", "Done");
-        return () => {
-          for (const subDestroy of destroyables) {
-            subDestroy();
-          }
-        };
-      }
-    };
-  }
-};
-function parseSpecifier(specifier) {
-  let name = "";
-  let version = "";
-  let path = ".";
-  const chars = specifier.split("");
-  const hasScope = chars[0] === "@";
-  let isVersion = false;
-  let isPath = false;
-  let finishedName = false;
-  let slashCount = 0;
-  for (let i2 = 0; i2 < chars.length; i2++) {
-    const char = chars[i2];
-    if (char === "@" && i2 > 0) {
-      finishedName = true;
-      isVersion = true;
-      continue;
-    } else if (char === "/") {
-      slashCount++;
-      if (hasScope) {
-        if (slashCount > 1) {
-          finishedName = true;
-        }
-      } else {
-        finishedName = true;
-      }
-      if (finishedName) {
-        isPath = true;
-      }
-    }
-    if (isVersion && char === "/") {
-      isVersion = false;
-      isPath = true;
-    }
-    if (isVersion) {
-      version += char;
-    } else if (isPath) {
-      path += char;
-    } else {
-      name += char;
-    }
-  }
-  return {
-    name,
-    version: version || void 0,
-    path
-  };
-}
-function splitSubPath(importPath) {
-  const parsed = parseSpecifier(importPath);
-  return [parsed.name, parsed.path === "." ? "" : parsed.path];
-}
-function esmSh(versions, importPath, allExternal = false) {
-  const [name, subPath] = splitSubPath(importPath);
-  const version = versions[name];
-  const subPathExport = subPath.length === 0 || subPath.startsWith("/") ? subPath : `/${subPath}`;
-  const externals = allExternal ? "*" : "";
-  return version ? `https://esm.sh/${externals}${name}@${version}${subPathExport}` : `https://esm.sh/${externals}${name}${subPathExport}`;
-}
-const esmsh = {
-  /**
-   * @param {Record<string, string>} versions
-   * @param {string} importPath
-   */
-  async import(versions, importPath) {
-    const url = esmSh(versions, importPath);
-    return await import(
-      /* @vite-ignore */
-      url
-    );
-  },
-  /**
-   * @param {Record<string, string>} versions
-   * @param {string[]} deps the names of deps to pull from esm.sh
-   */
-  async importAll(versions, deps = []) {
-    return await Promise.all(
-      deps.map((dep) => {
-        return esmsh.import(versions, dep);
-      })
-    );
-  }
-};
-const mermaid = {
-  needsLiveMeta: false,
-  codemirror: {
-    lang: async () => {
-      const { mermaid: mermaid2 } = await import("codemirror-lang-mermaid");
-      return mermaid2();
-    }
-  },
-  compiler: async (config, api) => {
-    const versions = config.versions;
-    const { default: mermaid2 } = await api.tryResolve("mermaid", () => {
-      return esmsh.import(versions, "mermaid");
-    });
-    let id = 0;
-    return {
-      compile: async (text) => {
-        return `export default \`${text}\`;`;
-      },
-      render: async (element, text, _, compiler) => {
-        const { svg } = await mermaid2.render("graphDiv" + id++, text);
-        element.innerHTML = svg;
-        compiler.announce("info", "Done");
-      }
-    };
-  }
-};
-const jsx = {
-  codemirror: {
-    lang: async () => {
-      const { javascript } = await import("@codemirror/lang-javascript");
-      return javascript({ jsx: true });
-    }
-  },
-  resolve: (id) => {
-    switch (id) {
-      case "react":
-        return `https://esm.sh/react`;
-      case "react-dom/client":
-        return `https://esm.sh/react-dom/client`;
-      case "@babel/standalone":
-        return `https://esm.sh/@babel/standalone`;
-    }
-  },
-  compiler: async (config, api) => {
-    const [reactDom, babel] = await api.tryResolveAll(["react-dom/client", "@babel/standalone"]);
-    const { createRoot } = reactDom;
-    return {
-      async compile(text) {
-        const result = babel.transform(text, {
-          filename: `repl.js`,
-          presets: [babel.availablePresets.react]
-        });
-        return result.code;
-      },
-      async render(element, component) {
-        const root = createRoot(element);
-        await new Promise((resolve2) => requestAnimationFrame(resolve2));
-        root.render(component);
-        await new Promise((resolve2) => requestAnimationFrame(resolve2));
-      }
-    };
-  }
-};
-const svelte = {
-  codemirror: {
-    lang: async () => {
-      const { svelte: svelte2 } = await import("@replit/codemirror-lang-svelte");
-      return svelte2();
-    }
-  },
-  /**
-   * Default config, known to work with how the compiler and render functions are configured.
-   */
-  resolve: (id) => {
-    if (["svelte"].some((x) => id.startsWith(x))) {
-      return esmSh(
-        {
-          svelte: "5.35.7"
-        },
-        id,
-        false
-      ) + // + '?target=esnext';
-      "?dev&target=esnext&keep-names";
-    }
-    if ([
-      "zimmerframe",
-      "locate-character",
-      "acorn",
-      "clsx",
-      "magic-string",
-      "@ampproject/remapping",
-      "@jridgewell/sourcemap-codec",
-      "axobject-query",
-      "esrap",
-      "is-reference",
-      "aria-query",
-      "@sveltejs/acorn-typescript"
-    ].some((x) => id.startsWith(x))) {
-      return esmSh({}, id, false);
-    }
-  },
-  compiler: async (config, api) => {
-    const [svelte2, compiler] = await api.tryResolveAll(["svelte", "svelte/compiler"]);
-    return {
-      compile: async (text, options) => {
-        const output = await compiler.compile(text, {
-          /* this errors if unexpected options are passed */
-          generate: "client",
-          fragments: "html",
-          // Placeholder for now until multiple files are supported
-          filename: "repl-sdk.svelte",
-          dev: true,
-          runes: true
-          // experimental: {
-          //   async: true,
-          // },
-        });
-        return { compiled: output.js.code, css: output.css?.code };
-      },
-      render: async (element, component, { css }) => {
-        const div = document.createElement("div");
-        if (css) {
-          const style = document.createElement("style");
-          style.innerHTML = /** @type {string} */
-          css;
-          element.appendChild(style);
-        }
-        element.appendChild(div);
-        requestAnimationFrame(() => {
-          svelte2.mount(component, {
-            target: element,
-            props: {
-              /* no props */
-            }
-          });
-          api.announce("info", "Done");
-        });
-      }
-    };
-  }
-};
-const vue = {
-  codemirror: {
-    lang: async () => {
-      const { vue: vue2 } = await import("@codemirror/lang-vue");
-      return vue2();
-    }
-  },
-  /**
-   * Default config, known to work with how the compiler and render functions are configured.
-   */
-  resolve: (id) => {
-    switch (id) {
-      case "vue":
-        return `https://cdn.jsdelivr.net/npm/vue@3.5.16/+esm`;
-      case "@vue/repl":
-        return `https://cdn.jsdelivr.net/npm/@vue/repl@4.5.1/+esm`;
-    }
-  },
-  compiler: async (config, api) => {
-    const [{ createApp }, { compileFile, useStore }] = await api.tryResolveAll([
-      "vue",
-      "@vue/repl"
-    ]);
-    const store = useStore();
-    return {
-      compile: async (text, options) => {
-        const output = { js: "", css: "", ssr: "" };
-        await compileFile(store, {
-          code: text,
-          filename: options.fileName,
-          language: "vue",
-          compiled: output
-        });
-        return { compiled: output.js, css: output.css };
-      },
-      render: async (element, component, { css }, compiler) => {
-        const div = document.createElement("div");
-        const style = document.createElement("style");
-        style.innerHTML = /** @type {string} */
-        css;
-        element.appendChild(div);
-        element.appendChild(style);
-        createApp(component).mount(div);
-        compiler.announce("info", "Done");
-      }
-    };
-  }
-};
-const compilers = {
-  hbs: {
-    /**
-     * ember has historically used a subset of HBS, and then built its own features on top of.
-     *
-     * It is not "handlebars", but does share a lot of similarities.
-     * (and these continue in ember's new gjs and gts formats)
-     *
-     */
-    ember: hbs
-  },
-  /**
-   * Markdown, but every code fense can be a live "Island"
-   * if `live` is in the codefence's meta tag and the compiler
-   * is registered here, or by the user of repl-sdk.
-   */
-  md,
-  /**
-   * Glimmer-flavored Markdown.
-   *
-   * Like the markdow renderer, but the resulting HTML
-   * is a Glimmer Component, rather than just plain HTML.
-   *
-   * https://emberjs.com
-   * https://repl.nullvoxpopuli.com
-   * https://kolay.nullvoxpopuli.com
-   * https://tutorial.glimdown.com
-   * https://limber.glimdown.com
-   */
-  gmd,
-  /**
-   * Glimmer-Flavored JavaScript
-   *
-   * https://emberjs.com
-   */
-  gjs,
-  /**
-   * TODO:
-   * Glimmer-flavored TypeScript
-   *
-   * https://emberjs.com
-   */
-  // gts: ember.gts,
-  /**
-   * Just vanilla JS.
-   */
-  js,
-  /**
-   * JSX is too overloaded to treat one way.
-   * We need to split this, and then make folks choose which one to use
-   * - jsx-react
-   * - jsx-vue
-   * - jsx-solid
-   * - (etc)
-   *
-   * This means that as a generic compiler, we can't just have jsx support.
-   * And in markdown, we'll need to support choosing which flavor of jsx
-   * via meta tags on the codefences.
-   *
-   * For example:
-   * ```jsx solid
-   * export default <></>;
-   * ```
-   *
-   * or
-   * ```jsx react
-   * export default <></>;
-   * ```
-   */
-  jsx: {
-    /**
-     * https://react.dev/
-     */
-    react: jsx
-    /**
-     * TODO:
-     * https://www.solidjs.com/
-     */
-    // solid: solid.jsx,
-  },
-  /**
-   * https://mermaid.js.org/
-   */
-  mermaid,
-  /**
-   * https://svelte.dev/
-   */
-  svelte,
-  /**
-   * https://vuejs.org/
-   */
-  vue
-};
-const STABLE_REFERENCE = {
-  resolve: () => {
-    throw new Error(
-      `'resolve' not implemented in STABLE_REFERENCE. Has the Compiler been set up correctly?`
-    );
-  },
-  fetch: async () => {
-    throw new Error(
-      `'fetch' not implemented in STABLE_REFERENCE. Has the Compiler been set up correctly?`
-    );
-  }
-};
-globalThis.esmsInitOptions = {
-  shimMode: true,
-  // skip: [`https://esm.sh`, 'https://jspm.dev/', 'https://cdn.jsdelivr.net/'],
-  revokeBlobURLs: true,
-  // default false
-  mapOverrides: true,
-  // default false
-  /**
-   * @param {string} id
-   * @param {string} parentUrl
-   * @param {(id: string, parentUrl: string) => string} resolve
-   * @returns {string}
-   */
-  resolve: (id, parentUrl, resolve2) => STABLE_REFERENCE.resolve(id, parentUrl, resolve2),
-  // NOTE: may need source hook
-  //       https://github.com/guybedford/es-module-shims?tab=readme-ov-file#source-hook
-  //
-  /**
-   * @param {string} url
-   * @param {RequestInit} options
-   * @returns {Promise<Response>}
-   */
-  fetch: (url, options) => STABLE_REFERENCE.fetch(url, options)
-};
-let requestId = 1;
-function requestKey() {
-  return `repl-request-${requestId++}`;
-}
-function getTarRequestId({ to, from }) {
-  const request = Request.of({ to, from });
-  const key = requestKey();
-  cache.requestCache.set(key, request);
-  return `${unzippedPrefix}/${key}`;
-}
-class Request {
-  static get #idCache() {
-    return cache.requestCache;
-  }
-  /**
-   * @param {{ to: string, from?: string }} toFrom
-   */
-  static of({ to, from }) {
-    const isRoot = to.match(/^[A-Za-z@]/);
-    const fromId = from?.replace(unzippedPrefix + "/", "");
-    const request = Request.fromSpecifier(isRoot ? to : `${to}?from=${fromId}`);
-    return request;
-  }
-  /**
-   * @param {string} id
-   */
-  static fromRequestId(id) {
-    const request = Request.#idCache.get(id);
-    assert(`Could not find request from id:${id}`, request);
-    return request;
-  }
-  /**
-   * @param {string} specifier
-   */
-  static fromSpecifier(specifier) {
-    return new Request(specifier);
-  }
-  /** @type {string} */
-  #to;
-  /** @type {Request | undefined} */
-  #from;
-  /**
-   * @private
-   * @param {string} specifier
-   */
-  constructor(specifier) {
-    const removedPrefix = specifier.replace(unzippedPrefix, "");
-    const [full, query] = removedPrefix.split("?");
-    this.original = specifier;
-    assert(`Invalid specifier: ${specifier}`, full);
-    if (full.startsWith(".") || full.startsWith("#")) {
-      if (!query) {
-        throw new Error(
-          `Missing query, ?from for specifier: ${specifier}. From is required for relative and subpath-imports.`
-        );
-      }
-    }
-    this.#to = full;
-    if (query) {
-      const search = new URLSearchParams(query);
-      const fromQp = search.get("from");
-      assert(`Missing query, ?from for specifier: ${specifier}`, fromQp);
-      const from = Request.fromRequestId(fromQp);
-      this.#from = from;
-      this.name = from.name;
-      this.version = from.version;
-    } else {
-      const parsed = parseSpecifier(full);
-      const { name, version = "latest", path } = parsed;
-      this.name = name;
-      this.version = version.replace(/\.+$/, "");
-      this.#to = path;
-    }
-  }
-  get to() {
-    return this.#to;
-  }
-  get from() {
-    return this.#from;
-  }
-  get key() {
-    return `__name__/${this.name}[AT:V]${this.version}/__to__/${this.to}`;
-  }
-}
-const CONDITIONS = ["repl", "module", "browser", "import", "default", "development"];
-const resolveCache = /* @__PURE__ */ new Map();
-const AT = "___AT___";
-const fakeProtocol = "repl://";
-function resolvePath(start, target) {
-  const base = start.replace(/^@([^/]+)\/([^/]+)/, `${AT}$1___$2`);
-  const url = new URL(target, fakeProtocol + fakeDomain + base);
-  return url.href.replace(fakeProtocol + fakeDomain, "").replace(AT, "@").replace("___", "/").replace(/^\//, "./");
-}
-function resolve(untarred, request) {
-  let answer = void 0;
-  const key = request.key;
-  if (resolveCache.has(key)) {
-    return resolveCache.get(key);
-  }
-  answer ||= fromImports(untarred, request, answer);
-  answer ||= fromInternalImport(untarred, request, answer);
-  answer ||= fromExportsString(untarred, request, answer);
-  answer ||= fromExports(untarred, request, answer);
-  answer ||= fromModule(untarred, request, answer);
-  answer ||= fromBrowser(untarred, request, answer);
-  answer ||= fromMain(untarred, request, answer);
-  answer ||= fromIndex(untarred, request, answer);
-  answer ||= fromFallback(untarred, request, answer);
-  if (answer) {
-    resolveCache.set(key, answer);
-  }
-  return answer;
-}
-function fromInternalImport(untarred, request, answer) {
-  if (answer) return answer;
-  if (!request.from) return answer;
-  const fromSpecifier = request.from;
-  const answerFrom = resolve(untarred, fromSpecifier);
-  if (!answerFrom) {
-    printError(untarred, fromSpecifier, answer);
-    return;
-  }
-  const inTarFile = resolvePath(
-    fromSpecifier.name + "/" + answerFrom.inTarFile,
-    request.to
-  ).replace(new RegExp(`^${fromSpecifier.name}/`), "");
-  const result = checkFile(untarred, inTarFile);
-  if (result) {
-    return createAnswer(result, request, "internalImport");
-  }
-  printError(untarred, request, answer);
-}
-function fromExports(untarred, request, answer) {
-  if (answer) return answer;
-  const exports$1 = untarred.manifest.exports;
-  if (!(typeof exports$1 === "object")) return answer;
-  const foundArray = exports(untarred.manifest, request.to, {
-    conditions: CONDITIONS
-  });
-  const found = foundArray?.map((f) => checkFile(untarred, f)).find(Boolean);
-  if (found) {
-    return createAnswer(found, request, "exports");
-  }
-}
-function fromImports(untarred, request, answer) {
-  if (answer) return answer;
-  if (!request.to.startsWith("#")) return answer;
-  const imports = untarred.manifest.imports;
-  if (!(typeof imports === "object")) return answer;
-  const found = resolve$2({ content: untarred.manifest }, request.to, {
-    conditions: CONDITIONS
-  });
-  if (found) {
-    return createAnswer(found.replace(/^\.\//, ""), request, "imports");
-  }
-}
-function fromExportsString(untarred, request, answer) {
-  if (answer) return answer;
-  if (!hasExports(untarred)) return answer;
-  return checkLegacyEntry(untarred, request, "exports");
-}
-function fromModule(untarred, request, answer) {
-  if (answer) return answer;
-  if (hasExports(untarred)) return answer;
-  return checkLegacyEntry(untarred, request, "module");
-}
-function fromBrowser(untarred, request, answer) {
-  if (answer) return answer;
-  if (hasExports(untarred)) return answer;
-  return checkLegacyEntry(untarred, request, "browser");
-}
-function fromMain(untarred, request, answer) {
-  if (answer) return answer;
-  if (hasExports(untarred)) return answer;
-  return checkLegacyEntry(untarred, request, "main");
-}
-function checkLegacyEntry(untarred, request, entryName) {
-  if (request.to !== ".") return;
-  const filePath = untarred.manifest[
-    /** @type {keyof typeof untarred.manifest} */
-    entryName
-  ];
-  if (!filePath || typeof filePath !== "string") return;
-  const result = checkFile(untarred, filePath);
-  if (result) {
-    return createAnswer(result, request, entryName);
-  }
-}
-function fromIndex(untarred, request, answer) {
-  if (answer) return answer;
-  if (hasExports(untarred)) return answer;
-  if (request.to === ".") {
-    if (untarred.contents["index.js"]) {
-      return {
-        inTarFile: "index.js",
-        ext: "js",
-        from: "index"
-      };
-    }
-  }
-}
-function fromFallback(untarred, request, answer) {
-  if (answer) return answer;
-  const result = checkFile(untarred, request.to);
-  if (result) {
-    return createAnswer(result, request, "fallback");
-  }
-}
-function checkFile(untarred, filePath) {
-  if (!filePath) return;
-  for (const prefix of ["", "pkg/"]) {
-    const path = prefix + filePath;
-    const dotless = prefix + filePath.replace(/^\.\//, "");
-    if (untarred.contents[path]) {
-      return path;
-    }
-    if (untarred.contents[dotless]) {
-      return dotless;
-    }
-  }
-}
-function extName(filePath) {
-  return filePath.split(".").pop();
-}
-function hasExports(untarred) {
-  return Boolean(untarred.manifest.exports);
-}
-function createAnswer(forFile, request, fromMethod) {
-  const ext = extName(forFile);
-  assert(
-    `All files must have an extension. This file (in ${request.name}) did not have an extension: ${forFile}`,
-    ext
-  );
-  return {
-    inTarFile: forFile,
-    ext,
-    from: fromMethod
-  };
-}
-function printError(untarred, request, answer) {
-  const { name, exports: exports2, main, module, browser } = untarred.manifest;
-  console.group(`${name} file info`);
-  console.info(`${name} has these files: `, Object.keys(untarred.contents));
-  console.info(`We searched for '${request.original}'`);
-  console.info(`from: `, { exports: exports2, main, module, browser });
-  console.info(`And found: `, answer);
-  console.info(`The request was: `, request);
-  console.groupEnd();
-  debugger;
-  throw new Error(`Could not find file for ${request.original}`);
-}
-const worker = new Worker(new URL(
-  /* @vite-ignore */
-  "/assets/tar-worker-kdkltuRC.js",
-  import.meta.url
-), {
-  name: "Tar & NPM Downloader Worker",
-  type: "module"
-});
-const com = wrap(worker);
-async function getFromTarball(url) {
-  const key = url.replace(unzippedPrefix + "/", "");
-  const request = cache.requestCache.get(key);
-  assert(`Missing request for ${url}`, request);
-  if (cache.fileCache.has(key)) {
-    return cache.fileCache.get(key);
-  }
-  const data = await cache.cachedPromise(key, async () => {
-    const untarred2 = await com.getTar(request.name, request.version);
-    const answer = resolve(untarred2, request);
-    if (!answer) {
-      throw new Error(`Could not find file for ${request.original}`);
-    }
-    return { answer, name: request.name, version: request.version };
-  });
-  const untarred = await com.getTar(request.name, request.version);
-  const result = getFile(untarred, key, data.answer);
-  assert(`Missing file for ${url}`, result);
-  cache.fileCache.set(key, result);
-  return result;
-}
-function getFile(untarred, key, answer) {
-  const request = Request.fromRequestId(key);
-  if (!answer) {
-    printError(untarred, request, answer);
-    return;
-  }
-  const { inTarFile, ext } = answer;
-  const code = untarred.contents[inTarFile]?.text;
-  if (!code) {
-    printError(untarred, request, answer);
-    return;
-  }
-  return { code, ext };
-}
-assert(`There is no document. repl-sdk is meant to be ran in a browser`, globalThis.document);
-const defaultFormats = Object.keys(compilers);
-const defaults = {
-  formats: compilers
-};
-class Compiler {
-  /** @type {Options} */
-  #options;
-  /**
-   * Options may be passed to the compiler to add to its behavior.
-   * @param {Partial<Options>} options
-   */
-  constructor(options = defaults) {
-    this.#options = Object.assign({}, defaults, options);
-    STABLE_REFERENCE.resolve = this.#resolve;
-    STABLE_REFERENCE.fetch = this.#fetch;
-    window.addEventListener("unhandledrejection", this.#handleUnhandledRejection);
-  }
-  /**
-   *
-   * @param {HTMLElement} element
-   * @param {any} options
-   */
-  async createEditor(element, { text, format, handleUpdate, extensions }) {
-    return cache.cachedPromise("codemirror", async () => {
-      const { buildCodemirror } = await import("./codemirror-D4aIVflZ.js");
-      return buildCodemirror({
-        element,
-        text,
-        format,
-        extensions,
-        handleUpdate,
-        getLang: async (format2) => {
-          const [lang, flavor] = format2.split("|");
-          assert(`Could not determine 'lang' from format: ${format2}`, lang);
-          const compiler = this.#resolveFormat(lang, flavor);
-          const loadLang = compiler.codemirror?.lang;
-          assert(
-            `The compiler for '${format2}' is missing its configuration for 'codemirror.lang'`,
-            loadLang
-          );
-          return await loadLang();
-        },
-        getSupport: async (format2) => {
-          const [lang, flavor] = format2.split("|");
-          assert(`Could not determine 'lang' from format: ${format2}`, lang);
-          const compiler = this.#resolveFormat(lang, flavor);
-          const loadSupport = compiler.codemirror.support;
-          return await loadSupport?.();
-        }
-      });
-    });
-  }
-  /**
-   * @param {PromiseRejectionEvent} e
-   */
-  #handleUnhandledRejection = (e) => {
-    let handled = false;
-    for (const onUnhandled2 of this.#compilerOnUnhandled) {
-      onUnhandled2(e, (message) => {
-        this.#announce("error", message);
-        handled = true;
-      });
-      if (handled) break;
-    }
-    if (handled) return;
-    this.#announce("error", e.reason);
-  };
-  /**
-   * Order of preference
-   * 1. manually resolved (from the caller)
-   * 2. specified in the compiler config (to use CDN)
-   * 3. download tarball from npm
-   *    or resolve from already downloaded tarball
-   *
-   * NOTE: when we return a new URL, we want to collapse the parentURI
-   *       so that we don't get compound query params in nested requests.
-   *
-   * @param {string} id
-   * @param {string} parentUrl
-   * @param {(id: string, parentUrl: string) => string} resolve
-   * @returns {string}
-   */
-  #resolve = (id, parentUrl, resolve2) => {
-    const vanilla = deCDN(id);
-    this.#announce("info", `Loading ${vanilla}`);
-    this.#log("[resolve]", id, "from", parentUrl);
-    if (this.#options.resolve?.[vanilla]) {
-      this.#log(`[resolve] ${vanilla} found in manually specified resolver`);
-      return `manual:${vanilla}`;
-    }
-    for (const compilerResolve of this.#compilerResolvers) {
-      const result = compilerResolve(vanilla);
-      if (result) {
-        this.#log(`[resolve] ${vanilla} found in compiler config at ${result}.`);
-        if (typeof result === "function") {
-          return `configured:${vanilla}`;
-        }
-        return result;
-      }
-    }
-    if (parentUrl.startsWith(tgzPrefix) && (id.startsWith(".") || id.startsWith("#"))) {
-      const answer = getTarRequestId({ to: id, from: parentUrl });
-      return answer;
-    }
-    if (id.startsWith("https://")) return resolve2(id, parentUrl);
-    if (id.startsWith("blob:")) return resolve2(id, parentUrl);
-    if (id.startsWith(".")) return resolve2(id, parentUrl);
-    if (parentUrl.startsWith("https://") && parentUrl !== location.href)
-      return resolve2(id, parentUrl);
-    if (parentUrl.startsWith("https://") && parentUrl.startsWith("/"))
-      return resolve2(id, parentUrl);
-    if (id.startsWith("node:")) {
-      this.#log(`Is known node module: ${id}. Grabbing polyfill`);
-      if (id === "node:process") return prefix_tgz(`process`);
-      if (id === "node:buffer") return prefix_tgz(`buffer`);
-      if (id === "node:events") return prefix_tgz(`events`);
-      if (id === "node:path") return prefix_tgz(`path-browser`);
-      if (id === "node:util") return prefix_tgz(`util-browser`);
-      if (id === "node:crypto") return prefix_tgz(`crypto-browserify`);
-      if (id === "node:stream") return prefix_tgz(`stream-browserify`);
-      if (id === "node:fs") return prefix_tgz(`browserify-fs`);
-    }
-    this.#log(`[resolve] ${id} not found, deferring to npmjs.com's provided tarball`);
-    return getTarRequestId({ to: id, from: parentUrl });
-  };
-  /**
-   * @param {string} url
-   * @param {RequestInit} options
-   * @returns {Promise<Response>}
-   */
-  #fetch = async (url, options) => {
-    const mimeType = mime.getType(url) ?? "application/javascript";
-    this.#log(`[fetch] attempting to fetch: ${url}. Assuming ${mimeType}`);
-    if (url.startsWith("manual:")) {
-      const name = url.replace(/^manual:/, "");
-      this.#log("[fetch] resolved url in manually specified resolver", url);
-      const result = await this.#resolveManually(name);
-      assert(`Failed to resolve ${name}`, result);
-      const blobContent = `const mod = window[Symbol.for('${secretKey}')].resolves?.['${name}'];
-
-
-if (!mod) { throw new Error('Could not resolve \`${name}\`. Does the module exist? ( checked ${url} )') }
-
-${Object.keys(result).map((exportName) => {
-        if (exportName === "default") {
-          return `export default mod.default ?? mod;`;
-        }
-        return `export const ${exportName} = mod.${exportName};`;
-      }).join("\n")}
-            `;
-      const blob = new Blob(Array.from(blobContent), { type: mimeType });
-      this.#log(
-        `[fetch] returning blob mapping to manually resolved import for ${name}`
-        // blobContent
-      );
-      this.#announce("info", `Loaded ${name}`);
-      return new Response(blob);
-    }
-    if (url.startsWith("configured:")) {
-      const name = url.replace(/^configured:/, "");
-      this.#log(
-        "[fetch] resolved url in a preconfigured (in the compiler config) specified resolver",
-        url
-      );
-      let result;
-      for (const compilerResolve of this.#compilerResolvers) {
-        const fn = compilerResolve(name);
-        if (fn) {
-          this.#log(`[fetch] ${name} found in compiler config at ${result}.`);
-          result = await fn();
-        }
-      }
-      assert(`Failed to resolve ${name}`, result);
-      cache.resolves[name] = result;
-      const blobContent = `const mod = window[Symbol.for('${secretKey}')].resolves?.['${name}'];
-
-
-if (!mod) { throw new Error('Could not resolve \`${name}\`. Does the module exist? ( checked ${url} )') }
-
-${Object.keys(result).map((exportName) => {
-        if (exportName === "default") {
-          return `export default mod.default ?? mod;`;
-        }
-        return `export const ${exportName} = mod.${exportName};`;
-      }).join("\n")}
-            `;
-      const blob = new Blob(Array.from(blobContent), { type: mimeType });
-      this.#log(
-        `[fetch] returning blob mapping to configured resolved import for ${name}`
-        // blobContent
-      );
-      this.#announce("info", `Loaded ${name}`);
-      return new Response(blob);
-    }
-    if (url.startsWith(unzippedPrefix)) {
-      this.#log("[fetch] resolved url via tgz resolver", url, options);
-      const tarInfo = await getFromTarball(url);
-      assert(`Could not find file for ${url}`, tarInfo);
-      const { code, ext } = tarInfo;
-      const file = await this.#postProcess(code, ext);
-      const type = mime.getType(ext);
-      return new Response(new Blob([file], { type: type ?? "application/javascript" }));
-    }
-    if (url.startsWith("https://")) {
-      return fetch(url, options);
-    }
-    this.#log("[fetch] fetching url", url, options);
-    const response = await fetch(url, options);
-    if (!response.ok) return response;
-    const source = await response.text();
-    this.#announce("info", `Loaded ${url}`);
-    return new Response(new Blob([source], { type: "application/javascript" }));
-  };
-  /**
-   * NOTE: this does not resolve compilers that are not loaded yet.
-   * So there would be a bit of a race condition here if different compilers
-   * were to have incompatible post-processing handlers.
-   *
-   * @param {string} text
-   * @param {string} ext
-   */
-  async #postProcess(text, ext) {
-    let code = text;
-    for (const compiler of this.#compilers) {
-      if (compiler.handlers?.[ext]) {
-        code = await compiler.handlers[ext](code);
-      }
-    }
-    return code;
-  }
-  /**
-   * @param {string} format
-   * @param {string} text
-   * @param {{ fileName?: string, flavor?: string, [key: string]: unknown }} [ options ]
-   * @returns {Promise<{ element: HTMLElement, destroy: () => void }>}
-   */
-  async compile(format, text, options = {}) {
-    this.#announce("info", `Compiling ${format}`);
-    try {
-      return await this.#compile(format, text, options);
-    } catch (e) {
-      const message = e instanceof Error ? e.message : e;
-      this.#announce("error", String(message));
-      this.#error(e);
-      throw e;
-    }
-  }
-  /**
-   * @param {string} format
-   * @param {string} text
-   * @param {{ fileName?: string, flavor?: string, [key: string]: unknown }} [ options ]
-   * @returns {Promise<{ element: HTMLElement, destroy: () => void }>}
-   */
-  async #compile(format, text, options) {
-    this.#log("[compile] idempotently installing es-module-shim");
-    await import("es-module-shims");
-    const opts = { ...options };
-    opts.fileName ||= `dynamic.${format}`;
-    this.#log("[compile] compiling");
-    const compiler = await this.#getCompiler(format, opts.flavor);
-    const compiled = await compiler.compile(text, opts);
-    let compiledText = 'export default "failed to compile"';
-    let extras = { compiled: "" };
-    if (typeof compiled === "string") {
-      compiledText = compiled;
-      extras = { compiled: compiledText };
-    } else if (typeof compiled.compiled === "string") {
-      const { compiled: text2 } = compiled;
-      compiledText = text2;
-      extras = compiled;
-    } else {
-      let value = compiled;
-      if ("compiled" in compiled) {
-        value = compiled.compiled;
-        extras = compiled;
-      }
-      return this.#render(compiler, value, {
-        ...extras,
-        compiled: value
-      });
-    }
-    const asBlobUrl = textToBlobUrl(compiledText);
-    const { default: defaultExport } = await shimmedImport(
-      /* @vite-ignore */
-      asBlobUrl
-    );
-    this.#log("[compile] preparing to render", defaultExport, extras);
-    return this.#render(compiler, defaultExport, extras);
-  }
-  #compilerCache = /* @__PURE__ */ new WeakMap();
-  #compilers = /* @__PURE__ */ new Set();
-  #compilerResolvers = /* @__PURE__ */ new Set();
-  /**
-   * @type {Set<(e: PromiseRejectionEvent, handle: (message: string) => void) => void>}
-   */
-  #compilerOnUnhandled = /* @__PURE__ */ new Set();
-  /**
-   * @param {string} format
-   * @param {string | undefined} flavor
-   */
-  async #getCompiler(format, flavor) {
-    const config = this.#resolveFormat(format, flavor);
-    if (this.#compilerCache.has(config)) {
-      return this.#compilerCache.get(config);
-    }
-    if (config.resolve) {
-      this.#compilerResolvers.add(config.resolve);
-    }
-    if (config.onUnhandled) {
-      this.#compilerOnUnhandled.add(config.onUnhandled);
-    }
-    const options = this.optionsFor(format, flavor);
-    const compiler = await config.compiler(options, this.#nestedPublicAPI);
-    this.#compilerCache.set(config, compiler);
-    this.#compilers.add(compiler);
-    return compiler;
-  }
-  /**
-   * @param {string} format
-   * @param {string | undefined} flavor
-   * @returns {import('./types').CompilerConfig}
-   */
-  #resolveFormat(format, flavor) {
-    let config = this.#options.formats[format];
-    assert(
-      `${format} is not a configured format / extension. The currently configured formats are ${Object.keys(this.#options.formats).join(", ")}`,
-      config
-    );
-    if (flavor && flavor in config) {
-      config = /** @type {{ [flavor: string]: CompilerConfig}} */
-      config[flavor];
-    }
-    assert(
-      `The config for ${format}${flavor ? ` (using flavor ${flavor})` : ""} is missing the 'compiler' function. It had keys: ${Object.keys(
-        /** @type {any} */
-        config
-      )}. If this is a language with multiple flavors, make sure you specify the flavor.`,
-      "compiler" in /** @type {any} */
-      config
-    );
-    return (
-      /** @type {import('./types').CompilerConfig} */
-      config
-    );
-  }
-  /**
-   * @param {string} format
-   * @param {string | undefined} flavor
-   * @returns {{ [key: string]: unknown }}
-   */
-  #resolveUserOptions(format, flavor) {
-    let config = (
-      /** @type {{ [key: string]: unknown }} */
-      this.#options.options?.[format]
-    );
-    if (!config) return {};
-    if (flavor && flavor in config) {
-      config = /** @type {{ [key: string]: unknown }} */
-      config[flavor];
-    }
-    return config ?? {};
-  }
-  /**
-   * @param {import('./types.ts').Compiler} compiler
-   * @param {string} whatToRender
-   * @param {{ compiled: string } & Record<string, unknown>} extras
-   * @returns {Promise<{ element: HTMLElement, destroy: () => void }>}
-   */
-  async #render(compiler, whatToRender, extras) {
-    this.#announce("info", "Rendering");
-    const div = this.#createDiv();
-    assert(`Cannot render falsey values. Did compilation succeed?`, whatToRender);
-    const destroy = await compiler.render(div, whatToRender, extras, this.#nestedPublicAPI);
-    await new Promise((resolve2) => requestAnimationFrame(resolve2));
-    return {
-      element: div,
-      destroy: () => {
-        if (destroy) {
-          return destroy();
-        }
-      }
-    };
-  }
-  /**
-   * @param {string} format
-   * @param {string | undefined} flavor
-   */
-  optionsFor = (format, flavor) => {
-    const { needsLiveMeta } = this.#resolveFormat(format, flavor);
-    return {
-      needsLiveMeta: (
-        /* @type {boolean | undefined} */
-        needsLiveMeta ?? true
-      ),
-      versions: this.#options.versions ?? {},
-      ...this.#resolveUserOptions(format, flavor) ?? {}
-    };
-  };
-  static clearCache() {
-    cache.clear();
-  }
-  /**
-   * @param {string} name
-   * @param {(name?: string) => Promise<undefined | object>} [fallback]
-   * @returns {Promise<undefined | object>}
-   */
-  #resolveManually = async (name, fallback) => {
-    const existing = cache.resolves[name];
-    if (existing) {
-      this.#log("[#resolveManually]", name, "already resolved");
-      return existing;
-    }
-    let result = (
-      /** @type {object | undefined} */
-      await this.#options.resolve?.[name]
-    );
-    if (!result) {
-      this.#log(`[#resolveManually] Could not resolve ${name}`);
-    }
-    if (typeof result === "function") {
-      if (!result) {
-        this.#log(`[#resolveManually] Value for ${name} is a function. Invoking.`);
-      }
-      result = await result();
-    }
-    if (fallback) {
-      result = await fallback(name);
-    }
-    cache.resolves[name] ||= await result;
-    return result;
-  };
-  /**
-   * @type {import('./types.ts').PublicMethods}
-   */
-  #nestedPublicAPI = {
-    /**
-     * @param {'error' | 'info'} type
-     * @param {string} message
-     * @returns {void}
-     */
-    announce: (type, message) => this.#announce(type, message),
-    /**
-     * @param {string} name
-     * @param {(name?: string) => Promise<object | undefined>} [fallback]
-     * @returns {Promise<object | undefined>}
-     */
-    tryResolve: async (name, fallback) => {
-      const existing = await this.#resolveManually(name, fallback);
-      if (existing) {
-        this.#log(name, "already resolved");
-        return existing;
-      }
-      const shimmed = await shimmedImport(
-        /* vite-ignore */
-        name
-      );
-      return shimmed;
-    },
-    /**
-     * @param {string[]} names
-     * @param {(name?: string) => Promise<unknown>} [fallback]
-     * @returns {Promise<unknown[]>}
-     */
-    tryResolveAll: async (names, fallback) => {
-      const results = await Promise.all(
-        names.map((name) => {
-          return this.#nestedPublicAPI.tryResolve(name);
-        })
-      );
-      if (fallback) {
-        const morePromises = {};
-        for (let i2 = 0; i2 < results.length; i2++) {
-          const result = results[i2];
-          const name = names[i2];
-          if (!result) {
-            this.#warn(`Could not load ${name}. Trying fallback.`);
-            morePromises[i2] = fallback(name);
-          }
-        }
-        await Promise.all(Object.values(morePromises));
-        for (let i2 = 0; i2 < results.length; i2++) {
-          results[i2];
-        }
-      }
-      return results;
-    },
-    /**
-     * @param {Parameters<Compiler['compile']>} args
-     */
-    compile: (...args) => this.compile(...args),
-    /**
-     * @param {Parameters<Compiler['optionsFor']>} args
-     */
-    optionsFor: (...args) => this.optionsFor(...args),
-    canCompile: (format, flavor) => {
-      let config = this.#options.formats[format];
-      if (!config) {
-        return {
-          result: false,
-          reason: `${format} is not a configured format / extension. The currently configured formats are ${Object.keys(this.#options.formats).join(", ")}`
-        };
-      }
-      if (flavor && flavor in config) {
-        config = /** @type {{ [flavor: string]: CompilerConfig}} */
-        config[flavor];
-      }
-      if (!config) {
-        return {
-          result: false,
-          reason: `${format} for ${flavor} is not a configured format / extension. The currently configured formats are ${Object.keys(this.#options.formats).join(", ")}`
-        };
-      }
-      if ("compiler" in config) {
-        return { result: true };
-      }
-      return {
-        result: false,
-        reason: `The config for ${format}${flavor ? ` (using flavor ${flavor})` : ""} is missing the 'compiler' function. It had keys: ${Object.keys(config)}. If this is a language with multiple flavors, make sure you specify the flavor.`
-      };
-    },
-    getCompiler: (format, flavor) => this.#getCompiler(format, flavor),
-    getAllowedFormats: () => Object.keys(this.#options.formats),
-    getFlavorsFor: (format) => {
-      const config = this.#options.formats[format];
-      if (!config) return [];
-      if (typeof config === "function") return [];
-      if (typeof config === "object") {
-        return Object.keys(config);
-      }
-      return [];
-    }
-  };
-  #createDiv() {
-    const div = document.createElement("div");
-    div.setAttribute("data-repl-output", "");
-    div.id = nextId();
-    return div;
-  }
-  /**
-   * @param {'error' | 'info'} type
-   * @param {string} message
-   */
-  #announce(type, message) {
-    if (!this.#options?.on?.log) return;
-    this.#options.on.log(type, message);
-  }
-  /**
-   * @param {Parameters<typeof console.debug>} args
-   */
-  #log(...args) {
-    if (this.#options.logging) {
-      console.debug(...args);
-    }
-  }
-  /**
-   * @param {Parameters<typeof console.warn>} args
-   */
-  #warn(...args) {
-    if (this.#options.logging) {
-      console.warn(...args);
-    }
-  }
-  /**
-   * @param {Parameters<typeof console.error>} args
-   */
-  #error(...args) {
-    if (this.#options.logging) {
-      console.error(...args);
-    }
-  }
-  /**
-   * @param {string} message
-   */
-  announceError(message) {
-    this.#announce("error", message);
-  }
-}
-function textToBlobUrl(text) {
-  const blob = new Blob([text], { type: "text/javascript" });
-  const blobUrl = URL.createObjectURL(blob);
-  return blobUrl;
-}
-function shimmedImport(...args) {
-  if (!globalThis.importShim) {
-    throw new Error(`Could not find importShim. Has the REPL been set up correctly?`);
-  }
-  return globalThis.importShim(...args);
-}
-function deCDN(id) {
-  const noQPs = id.split("?")[0];
-  return (
-    /** @type {string} */
-    noQPs
-  );
-}
-export {
-  Compiler as C,
-  assert as a,
-  buildCodeFenceMetaUtils as b,
-  defaults as c,
-  defaultFormats as d,
-  isRecord as i,
-  nextId as n
-};
-//# sourceMappingURL=index-CUWCqMoD.js.map