@marko/vite 3.1.6 → 4.0.0

package/dist/index.js

@@ -1,687 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-__export(src_exports, {
-  default: () => markoPlugin
-});
-module.exports = __toCommonJS(src_exports);
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_crypto = __toESM(require("crypto"));
-var import_anymatch = __toESM(require("anymatch"));
-var import_url = require("url");
-var import_server_entry_template = __toESM(require("./server-entry-template"));
-var import_manifest_generator = require("./manifest-generator");
-var import_esbuild_plugin = __toESM(require("./esbuild-plugin"));
-var import_store = require("./store");
-var import_babel_plugin_cjs_interop = __toESM(require("./babel-plugin-cjs-interop"));
-var import_resolve = require("./resolve");
-__reExport(src_exports, require("./store"), module.exports);
-const import_meta = {};
-const POSIX_SEP = "/";
-const WINDOWS_SEP = "\\";
-const normalizePath = import_path.default.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
-const virtualFiles = /* @__PURE__ */ new Map();
-const queryReg = /\?marko-[^?]+$/;
-const browserEntryQuery = "?marko-browser-entry";
-const serverEntryQuery = "?marko-server-entry";
-const virtualFileQuery = "?marko-virtual";
-const browserQuery = "?marko-browser";
-const manifestFileName = "manifest.json";
-const markoExt = ".marko";
-const htmlExt = ".html";
-const resolveOpts = { skipSelf: true };
-const cache = /* @__PURE__ */ new Map();
-const thisFile = typeof __filename === "string" ? __filename : (0, import_url.fileURLToPath)(import_meta.url);
-const babelCaller = {
-  name: "@marko/vite",
-  supportsStaticESM: true,
-  supportsDynamicImport: true,
-  supportsTopLevelAwait: true,
-  supportsExportNamespaceFrom: true
-};
-let registeredTag = false;
-function markoPlugin(opts = {}) {
-  let compiler;
-  let { linked = true } = opts;
-  let runtimeId;
-  let basePathVar;
-  let baseConfig;
-  let ssrConfig;
-  let ssrCjsConfig;
-  let domConfig;
-  let hydrateConfig;
-  const resolveVirtualDependency = (from, dep) => {
-    const normalizedFrom = normalizePath(from);
-    const query = `${virtualFileQuery}&id=${Buffer.from(dep.virtualPath).toString("base64url") + import_path.default.extname(dep.virtualPath)}`;
-    const id = normalizePath(normalizedFrom) + query;
-    if (devServer) {
-      const prev = virtualFiles.get(id);
-      if (isDeferredPromise(prev)) {
-        prev.resolve(dep);
-      }
-    }
-    virtualFiles.set(id, dep);
-    return `./${import_path.default.posix.basename(normalizedFrom) + query}`;
-  };
-  let root;
-  let devEntryFile;
-  let devEntryFilePosix;
-  let isTest = false;
-  let isBuild = false;
-  let isSSRBuild = false;
-  let devServer;
-  let serverManifest;
-  let store;
-  let basePath = "/";
-  const entryIds = /* @__PURE__ */ new Set();
-  const cachedSources = /* @__PURE__ */ new Map();
-  const transformWatchFiles = /* @__PURE__ */ new Map();
-  const transformOptionalFiles = /* @__PURE__ */ new Map();
-  return [
-    {
-      name: "marko-vite:pre",
-      enforce: "pre",
-      // Must be pre to allow us to resolve assets before vite.
-      async config(config, env) {
-        var _a, _b, _c, _d, _e;
-        compiler ?? (compiler = await import(opts.compiler || "@marko/compiler"));
-        runtimeId = opts.runtimeId;
-        basePathVar = opts.basePathVar;
-        baseConfig = {
-          cache,
-          runtimeId,
-          sourceMaps: true,
-          writeVersionComment: false,
-          babelConfig: opts.babelConfig ? {
-            ...opts.babelConfig,
-            caller: opts.babelConfig.caller ? {
-              name: "@marko/vite",
-              supportsStaticESM: true,
-              supportsDynamicImport: true,
-              supportsTopLevelAwait: true,
-              supportsExportNamespaceFrom: true,
-              ...opts.babelConfig.caller
-            } : babelCaller
-          } : {
-            babelrc: false,
-            configFile: false,
-            browserslistConfigFile: false,
-            caller: babelCaller
-          }
-        };
-        ssrConfig = {
-          ...baseConfig,
-          resolveVirtualDependency,
-          output: "html"
-        };
-        domConfig = {
-          ...baseConfig,
-          resolveVirtualDependency,
-          output: "dom"
-        };
-        hydrateConfig = {
-          ...baseConfig,
-          resolveVirtualDependency,
-          output: "hydrate"
-        };
-        compiler.configure(baseConfig);
-        root = normalizePath(config.root || process.cwd());
-        devEntryFile = import_path.default.join(root, "index.html");
-        devEntryFilePosix = normalizePath(devEntryFile);
-        isTest = env.mode === "test";
-        isBuild = env.command === "build";
-        isSSRBuild = isBuild && linked && Boolean(config.build.ssr);
-        store = opts.store || new import_store.FileStore(
-          `marko-vite-${import_crypto.default.createHash("SHA1").update(root).digest("hex")}`
-        );
-        if (isTest) {
-          linked = false;
-          if ((_b = (_a = config.test) == null ? void 0 : _a.environment) == null ? void 0 : _b.includes(
-            "dom"
-          )) {
-            config.resolve ?? (config.resolve = {});
-            (_c = config.resolve).conditions ?? (_c.conditions = []);
-            config.resolve.conditions.push("browser");
-          }
-        }
-        if (!registeredTag) {
-          const transformer = import_path.default.resolve(
-            thisFile,
-            "../render-assets-transform"
-          );
-          registeredTag = normalizePath(
-            import_path.default.resolve(thisFile, "../components", "vite.marko")
-          );
-          compiler.taglib.register("@marko/vite", {
-            "<_vite>": { template: registeredTag },
-            "<head>": { transformer },
-            "<body>": { transformer }
-          });
-        }
-        const optimizeDeps = config.optimizeDeps ?? (config.optimizeDeps = {});
-        optimizeDeps.entries ?? (optimizeDeps.entries = [
-          "**/*.marko",
-          "!**/__snapshots__/**",
-          `!**/__tests__/**`,
-          `!**/coverage/**`
-        ]);
-        const domDeps = compiler.getRuntimeEntryFiles("dom", opts.translator);
-        optimizeDeps.include = optimizeDeps.include ? [...optimizeDeps.include, ...domDeps] : domDeps;
-        const optimizeExtensions = optimizeDeps.extensions ?? (optimizeDeps.extensions = []);
-        optimizeExtensions.push(".marko");
-        const esbuildOptions = optimizeDeps.esbuildOptions ?? (optimizeDeps.esbuildOptions = {});
-        const esbuildPlugins = esbuildOptions.plugins ?? (esbuildOptions.plugins = []);
-        esbuildPlugins.push((0, import_esbuild_plugin.default)(compiler, baseConfig));
-        const ssr = config.ssr ?? (config.ssr = {});
-        let { noExternal } = ssr;
-        if (noExternal !== true) {
-          const noExternalReg = /\.marko$/;
-          if (noExternal) {
-            if (Array.isArray(noExternal)) {
-              noExternal.push(noExternalReg);
-            } else {
-              noExternal = [noExternal, noExternalReg];
-            }
-          } else {
-            noExternal = noExternalReg;
-          }
-        }
-        if (basePathVar) {
-          config.experimental ?? (config.experimental = {});
-          if (config.experimental.renderBuiltUrl) {
-            throw new Error(
-              "Cannot use @marko/vite `basePathVar` with Vite's `renderBuiltUrl` option."
-            );
-          }
-          const assetsDir = ((_e = (_d = config.build) == null ? void 0 : _d.assetsDir) == null ? void 0 : _e.replace(/[/\\]$/, "")) ?? "assets";
-          const assetsDirLen = assetsDir.length;
-          const assetsDirEnd = assetsDirLen + 1;
-          const trimAssertsDir = (fileName) => {
-            if (fileName.startsWith(assetsDir)) {
-              switch (fileName[assetsDirLen]) {
-                case POSIX_SEP:
-                case WINDOWS_SEP:
-                  return fileName.slice(assetsDirEnd);
-              }
-            }
-            return fileName;
-          };
-          config.experimental.renderBuiltUrl = (fileName, { hostType, ssr: ssr2 }) => {
-            switch (hostType) {
-              case "html":
-                return trimAssertsDir(fileName);
-              case "js":
-                return {
-                  runtime: `${ssr2 ? basePathVar : `$mbp${runtimeId ? `_${runtimeId}` : ""}`}+${JSON.stringify(trimAssertsDir(fileName))}`
-                };
-              default:
-                return { relative: true };
-            }
-          };
-        }
-      },
-      configResolved(config) {
-        basePath = config.base;
-        ssrCjsConfig = {
-          ...ssrConfig,
-          //modules: 'cjs'
-          babelConfig: {
-            ...ssrConfig.babelConfig,
-            plugins: (ssrConfig.babelConfig.plugins || []).concat(
-              (0, import_babel_plugin_cjs_interop.default)({
-                extensions: config.resolve.extensions,
-                conditions: config.resolve.conditions
-              })
-            )
-          }
-        };
-      },
-      configureServer(_server) {
-        ssrConfig.hot = domConfig.hot = true;
-        devServer = _server;
-        devServer.watcher.on("all", (type, filename) => {
-          cachedSources.delete(filename);
-          if (type === "unlink") {
-            entryIds.delete(filename);
-            transformWatchFiles.delete(filename);
-            transformOptionalFiles.delete(filename);
-          }
-          for (const [id, files] of transformWatchFiles) {
-            if ((0, import_anymatch.default)(files, filename)) {
-              devServer.watcher.emit("change", id);
-            }
-          }
-          if (type === "add" || type === "unlink") {
-            for (const [id, files] of transformOptionalFiles) {
-              if ((0, import_anymatch.default)(files, filename)) {
-                devServer.watcher.emit("change", id);
-              }
-            }
-          }
-        });
-      },
-      handleHotUpdate(ctx) {
-        compiler.taglib.clearCaches();
-        baseConfig.cache.clear();
-        for (const mod of ctx.modules) {
-          if (mod.id && virtualFiles.has(mod.id)) {
-            virtualFiles.set(mod.id, createDeferredPromise());
-          }
-        }
-      },
-      async buildStart(inputOptions) {
-        if (isBuild && linked && !isSSRBuild) {
-          try {
-            serverManifest = JSON.parse(
-              await store.get(manifestFileName)
-            );
-            inputOptions.input = toHTMLEntries(root, serverManifest.entries);
-            for (const entry in serverManifest.entrySources) {
-              const id = normalizePath(import_path.default.resolve(root, entry));
-              entryIds.add(id);
-              cachedSources.set(id, serverManifest.entrySources[entry]);
-            }
-          } catch (err) {
-            this.error(
-              `You must run the "ssr" build before the "browser" build.`
-            );
-          }
-          if (isEmpty(inputOptions.input)) {
-            this.error("No Marko files were found when compiling the server.");
-          }
-        }
-      },
-      async resolveId(importee, importer, importOpts, ssr = importOpts.ssr) {
-        var _a;
-        if (virtualFiles.has(importee)) {
-          return importee;
-        }
-        let importeeQuery = getMarkoQuery(importee);
-        if (importeeQuery) {
-          importee = importee.slice(0, -importeeQuery.length);
-        } else if (!importOpts.scan) {
-          if (ssr && linked && importer && (importer !== devEntryFile || normalizePath(importer) !== devEntryFilePosix) && // Vite tries to resolve against an `index.html` in some cases, we ignore it here.
-          isMarkoFile(importee) && !isMarkoFile(importer.replace(queryReg, ""))) {
-            importeeQuery = serverEntryQuery;
-          } else if (!ssr && isBuild && importer && isMarkoFile(importee) && ((_a = this.getModuleInfo(importer)) == null ? void 0 : _a.isEntry)) {
-            importeeQuery = browserEntryQuery;
-          } else if (linked && !ssr && !importeeQuery && isMarkoFile(importee)) {
-            importeeQuery = browserQuery;
-          }
-        }
-        if (importeeQuery) {
-          const resolved = importee[0] === "." ? {
-            id: normalizePath(
-              importer ? import_path.default.resolve(importer, "..", importee) : import_path.default.resolve(root, importee)
-            )
-          } : await this.resolve(importee, importer, resolveOpts);
-          if (resolved) {
-            resolved.id += importeeQuery;
-          }
-          return resolved;
-        }
-        if (importer) {
-          const importerQuery = getMarkoQuery(importer);
-          if (importerQuery) {
-            importer = importer.slice(0, -importerQuery.length);
-            if (importee[0] === ".") {
-              const resolved = normalizePath(
-                import_path.default.resolve(importer, "..", importee)
-              );
-              if (resolved === normalizePath(importer))
-                return resolved;
-            }
-            return this.resolve(importee, importer, resolveOpts);
-          }
-        }
-        return null;
-      },
-      async load(rawId) {
-        const id = stripVersionAndTimeStamp(rawId);
-        const query = getMarkoQuery(id);
-        switch (query) {
-          case serverEntryQuery: {
-            entryIds.add(id.slice(0, -query.length));
-            return null;
-          }
-          case browserEntryQuery:
-          case browserQuery: {
-            return cachedSources.get(id.slice(0, -query.length)) || null;
-          }
-        }
-        return virtualFiles.get(id) || null;
-      },
-      async transform(source, rawId, ssr) {
-        let id = stripVersionAndTimeStamp(rawId);
-        const isSSR = typeof ssr === "object" ? ssr.ssr : ssr;
-        const query = getMarkoQuery(id);
-        if (query && !query.startsWith(virtualFileQuery)) {
-          id = id.slice(0, -query.length);
-          if (query === serverEntryQuery) {
-            const fileName = id;
-            let entryData;
-            id = `${id.slice(0, -markoExt.length)}.entry.marko`;
-            cachedSources.set(fileName, source);
-            if (isBuild) {
-              const relativeFileName = import_path.default.posix.relative(root, fileName);
-              const entryId = toEntryId(relativeFileName);
-              serverManifest ?? (serverManifest = {
-                entries: {},
-                entrySources: {},
-                chunksNeedingAssets: []
-              });
-              serverManifest.entries[entryId] = relativeFileName;
-              serverManifest.entrySources[relativeFileName] = source;
-              entryData = JSON.stringify(entryId);
-            } else {
-              entryData = JSON.stringify(
-                await (0, import_manifest_generator.generateDocManifest)(
-                  basePath,
-                  await devServer.transformIndexHtml(
-                    "/",
-                    (0, import_manifest_generator.generateInputDoc)(
-                      posixFileNameToURL(fileName, root) + browserEntryQuery
-                    )
-                  )
-                )
-              );
-            }
-            source = await (0, import_server_entry_template.default)({
-              fileName,
-              entryData,
-              runtimeId,
-              basePathVar: isBuild ? basePathVar : void 0
-            });
-          }
-        }
-        if (!isMarkoFile(id)) {
-          return null;
-        }
-        if (isSSR) {
-          if (linked) {
-            cachedSources.set(id, source);
-          }
-          if (!query && (0, import_resolve.isCJSModule)(id)) {
-            if (isBuild) {
-              const { code: code2, map: map2 } = await compiler.compile(
-                source,
-                id,
-                ssrCjsConfig
-              );
-              return { code: code2, map: map2, meta: { source } };
-            } else {
-              const { ast } = await compiler.compile(source, id, {
-                cache,
-                ast: true,
-                code: false,
-                output: "source",
-                sourceMaps: false
-              });
-              let namedExports = "";
-              let code2 = `import { createRequire } from "module";
-`;
-              code2 += `import "@marko/compiler/register.js";
-`;
-              code2 += `const mod = createRequire(import.meta.url)(${JSON.stringify(
-                id
-              )});
-`;
-              for (const child of ast.program.body) {
-                switch (child.type) {
-                  case "ExportAllDeclaration":
-                    code2 += `export * from ${JSON.stringify(
-                      child.source.value
-                    )};
-`;
-                    break;
-                  case "ExportNamedDeclaration":
-                    if (child.specifiers) {
-                      for (const specifier of child.specifiers) {
-                        if (specifier.exported.type === "Identifier") {
-                          namedExports += `${specifier.exported.name},`;
-                        } else {
-                          namedExports += `mod[${JSON.stringify(
-                            specifier.exported.value
-                          )}] as ${specifier.exported.value},`;
-                        }
-                      }
-                    }
-                    if (child.declaration) {
-                      if ("id" in child.declaration && child.declaration.id) {
-                        if (child.declaration.id.type === "Identifier") {
-                          namedExports += `${child.declaration.id.name},`;
-                        } else {
-                          namedExports += `mod[${JSON.stringify(
-                            child.declaration.id.value
-                          )}] as ${child.declaration.id.value},`;
-                        }
-                      }
-                      if ("declarations" in child.declaration) {
-                        for (const declaration of child.declaration.declarations) {
-                          if (declaration.id.type === "Identifier") {
-                            namedExports += `${declaration.id.name},`;
-                          }
-                        }
-                      }
-                    }
-                    break;
-                }
-              }
-              code2 += `export const { ${namedExports} } = mod;
-`;
-              code2 += `export default mod.default;
-`;
-              return code2;
-            }
-          }
-        }
-        const compiled = await compiler.compile(
-          source,
-          id,
-          isSSR ? ssrConfig : query === browserEntryQuery ? hydrateConfig : domConfig
-        );
-        const { map, meta } = compiled;
-        let { code } = compiled;
-        if (query !== browserEntryQuery && devServer) {
-          code += `
-if (import.meta.hot) import.meta.hot.accept(() => {});`;
-        }
-        if (devServer) {
-          const templateName = getPosixBasenameWithoutExt(id);
-          const optionalFilePrefix = import_path.default.dirname(id) + import_path.default.sep + (templateName === "index" ? "" : `${templateName}.`);
-          for (const file of meta.watchFiles) {
-            this.addWatchFile(file);
-          }
-          transformOptionalFiles.set(id, [
-            `${optionalFilePrefix}style.*`,
-            `${optionalFilePrefix}component.*`,
-            `${optionalFilePrefix}component-browser.*`,
-            `${optionalFilePrefix}marko-tag.json`
-          ]);
-          transformWatchFiles.set(id, meta.watchFiles);
-        }
-        return { code, map, meta: isBuild ? { source } : void 0 };
-      }
-    },
-    {
-      name: "marko-vite:post",
-      apply: "build",
-      enforce: "post",
-      // We use a "post" plugin to allow us to read the final generated `.html` from vite.
-      async generateBundle(outputOptions, bundle, isWrite) {
-        if (!linked) {
-          return;
-        }
-        if (!isWrite) {
-          this.error(
-            `Linked builds are currently only supported when in "write" mode.`
-          );
-        }
-        if (!serverManifest) {
-          this.error(
-            "No Marko files were found when bundling the server in linked mode."
-          );
-        }
-        if (isSSRBuild) {
-          const dir = outputOptions.dir ? import_path.default.resolve(outputOptions.dir) : import_path.default.resolve(outputOptions.file, "..");
-          for (const fileName in bundle) {
-            const chunk = bundle[fileName];
-            if (chunk.type === "chunk") {
-              for (const id in chunk.modules) {
-                if (id === registeredTag) {
-                  serverManifest.chunksNeedingAssets.push(
-                    import_path.default.resolve(dir, fileName)
-                  );
-                  break;
-                }
-              }
-            }
-          }
-          await store.set(manifestFileName, JSON.stringify(serverManifest));
-        } else {
-          const browserManifest = {};
-          for (const entryId in serverManifest.entries) {
-            const fileName = serverManifest.entries[entryId];
-            let chunkId = fileName + htmlExt;
-            let chunk = bundle[chunkId];
-            if (!chunk) {
-              chunkId = chunkId.replace(/\//g, "\\");
-              chunk = bundle[chunkId];
-            }
-            if ((chunk == null ? void 0 : chunk.type) === "asset") {
-              browserManifest[entryId] = {
-                ...await (0, import_manifest_generator.generateDocManifest)(
-                  basePath,
-                  chunk.source.toString()
-                ),
-                entries: void 0
-                // clear out entries for prod builds.
-              };
-              delete bundle[chunkId];
-            } else {
-              this.error(
-                `Marko template had unexpected output from vite, ${fileName}`
-              );
-            }
-          }
-          const manifestStr = `;var __MARKO_MANIFEST__=${JSON.stringify(
-            browserManifest
-          )};
-`;
-          for (const fileName of serverManifest.chunksNeedingAssets) {
-            await import_fs.default.promises.appendFile(fileName, manifestStr);
-          }
-        }
-      }
-    }
-  ];
-}
-function getMarkoQuery(id) {
-  var _a;
-  return ((_a = queryReg.exec(id)) == null ? void 0 : _a[0]) || "";
-}
-function isMarkoFile(id) {
-  return id.endsWith(markoExt);
-}
-function toHTMLEntries(root, serverEntries) {
-  const result = [];
-  for (const id in serverEntries) {
-    const markoFile = import_path.default.posix.join(root, serverEntries[id]);
-    const htmlFile = markoFile + htmlExt;
-    virtualFiles.set(htmlFile, {
-      code: (0, import_manifest_generator.generateInputDoc)(markoFile + browserEntryQuery)
-    });
-    result.push(htmlFile);
-  }
-  return result;
-}
-function toEntryId(id) {
-  const lastSepIndex = id.lastIndexOf(POSIX_SEP);
-  let name = id.slice(lastSepIndex + 1, id.indexOf(".", lastSepIndex));
-  if (name === "index" || name === "template") {
-    name = id.slice(
-      id.lastIndexOf(POSIX_SEP, lastSepIndex - 1) + 1,
-      lastSepIndex
-    );
-  }
-  return `${name}_${import_crypto.default.createHash("SHA1").update(id).digest("base64").replace(/[/+]/g, "-").slice(0, 4)}`;
-}
-function posixFileNameToURL(fileName, root) {
-  const relativeURL = import_path.default.posix.relative(
-    (0, import_url.pathToFileURL)(root).pathname,
-    (0, import_url.pathToFileURL)(fileName).pathname
-  );
-  if (relativeURL[0] === ".") {
-    throw new Error(
-      "@marko/vite: Entry templates must exist under the current root directory."
-    );
-  }
-  return `/${relativeURL}`;
-}
-function getPosixBasenameWithoutExt(file) {
-  const baseStart = file.lastIndexOf(POSIX_SEP) + 1;
-  const extStart = file.indexOf(".", baseStart + 1);
-  return file.slice(baseStart, extStart);
-}
-function createDeferredPromise() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  promise.resolve = resolve;
-  promise.reject = reject;
-  return promise;
-}
-function isDeferredPromise(obj) {
-  return typeof (obj == null ? void 0 : obj.then) === "function";
-}
-function isEmpty(obj) {
-  for (const _ in obj) {
-    return false;
-  }
-  return true;
-}
-function stripVersionAndTimeStamp(id) {
-  const queryStart = id.indexOf("?");
-  if (queryStart === -1)
-    return id;
-  const url = id.slice(0, queryStart);
-  const query = id.slice(queryStart + 1).replace(/(?:^|[&])[vt]=[^&]+/g, "");
-  if (query)
-    return `${url}?${query}`;
-  return url;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./store")
-});