vite 3.0.1 → 3.0.4

package/dist/node/chunks/{dep-10d8d214.js → dep-71eb12cb.js}

@@ -11754,7 +11754,7 @@ const dataUrlRE = /^\s*data:/i;
 const isDataUrl = (url) => dataUrlRE.test(url);
 const virtualModuleRE = /^virtual-module:.*/;
 const virtualModulePrefix = 'virtual-module:';
-const knownJsSrcRE = /\.((j|t)sx?|mjs|vue|marko|svelte|astro)($|\?)/;
+const knownJsSrcRE = /\.((j|t)sx?|m[jt]s|vue|marko|svelte|astro)($|\?)/;
 const isJSRequest = (url) => {
     url = cleanUrl(url);
     if (knownJsSrcRE.test(url)) {
@@ -12318,6 +12318,9 @@ function gracefulRemoveDir(dir, cb) {
 function emptyCssComments(raw) {
     return raw.replace(multilineCommentsRE$1, (s) => ' '.repeat(s.length));
 }
+function removeComments(raw) {
+    return raw.replace(multilineCommentsRE$1, '').replace(singlelineCommentsRE$1, '');
+}
 function mergeConfigRecursively(defaults, overrides, rootPath) {
     const merged = { ...defaults };
     for (const key in overrides) {
@@ -13244,12 +13247,15 @@ async function transformWithEsbuild(code, filename, options, inMap) {
         if (ext === 'cjs' || ext === 'mjs') {
             loader = 'js';
         }
+        else if (ext === 'cts' || ext === 'mts') {
+            loader = 'ts';
+        }
         else {
             loader = ext;
         }
     }
     let tsconfigRaw = options?.tsconfigRaw;
-    // if options provide tsconfigraw in string, it takes highest precedence
+    // if options provide tsconfigRaw in string, it takes highest precedence
     if (typeof tsconfigRaw !== 'string') {
         // these fields would affect the compilation result
         // https://esbuild.github.io/content-types/#tsconfig-json
@@ -13329,7 +13335,7 @@ async function transformWithEsbuild(code, filename, options, inMap) {
     }
 }
 function esbuildPlugin(options = {}) {
-    const filter = createFilter(options.include || /\.(tsx?|jsx)$/, options.exclude || /\.js$/);
+    const filter = createFilter(options.include || /\.(m?ts|[jt]sx)$/, options.exclude || /\.js$/);
     // Remove optimization options for dev as we only need to transpile them,
     // and for build as the final optimization is in `buildEsbuildPlugin`
     const transformOptions = {
@@ -13563,7 +13569,7 @@ function reloadOnTsconfigChange(changedFile) {
     if (path$n.basename(changedFile) === 'tsconfig.json' ||
         (changedFile.endsWith('.json') &&
             tsconfckParseOptions?.cache?.has(changedFile))) {
-        server.config.logger.info(`changed tsconfig file detected: ${changedFile} - Clearing cache and forcing full-reload to ensure typescript is compiled with updated config values.`, { clear: server.config.clearScreen, timestamp: true });
+        server.config.logger.info(`changed tsconfig file detected: ${changedFile} - Clearing cache and forcing full-reload to ensure TypeScript is compiled with updated config values.`, { clear: server.config.clearScreen, timestamp: true });
         // clear module graph to remove code compiled with outdated config
         server.moduleGraph.invalidateAll();
         // reset tsconfck so that recompile works with up2date configs
@@ -27478,10 +27484,10 @@ function getLineInfo(input, offset) {
 var defaultOptions = {
   // `ecmaVersion` indicates the ECMAScript version to parse. Must be
   // either 3, 5, 6 (or 2015), 7 (2016), 8 (2017), 9 (2018), 10
-  // (2019), 11 (2020), 12 (2021), 13 (2022), or `"latest"` (the
-  // latest version the library supports). This influences support
-  // for strict mode, the set of reserved words, and support for
-  // new syntax features.
+  // (2019), 11 (2020), 12 (2021), 13 (2022), 14 (2023), or `"latest"`
+  // (the latest version the library supports). This influences
+  // support for strict mode, the set of reserved words, and support
+  // for new syntax features.
   ecmaVersion: null,
   // `sourceType` indicates the mode the code should be parsed in.
   // Can be either `"script"` or `"module"`. This influences global
@@ -27515,8 +27521,9 @@ var defaultOptions = {
   // When enabled, super identifiers are not constrained to
   // appearing in methods and do not raise an error when they appear elsewhere.
   allowSuperOutsideMethod: null,
-  // When enabled, hashbang directive in the beginning of file
-  // is allowed and treated as a line comment.
+  // When enabled, hashbang directive in the beginning of file is
+  // allowed and treated as a line comment. Enabled by default when
+  // `ecmaVersion` >= 2023.
   allowHashBang: false,
   // When `locations` is on, `loc` properties holding objects with
   // `start` and `end` properties in `{line, column}` form (with
@@ -27591,6 +27598,9 @@ function getOptions(opts) {
   if (options.allowReserved == null)
     { options.allowReserved = options.ecmaVersion < 5; }
 
+  if (opts.allowHashBang == null)
+    { options.allowHashBang = options.ecmaVersion >= 14; }
+
   if (isArray(options.onToken)) {
     var tokens = options.onToken;
     options.onToken = function (token) { return tokens.push(token); };
@@ -27921,7 +27931,7 @@ pp$9.checkPatternErrors = function(refDestructuringErrors, isAssign) {
   if (refDestructuringErrors.trailingComma > -1)
     { this.raiseRecoverable(refDestructuringErrors.trailingComma, "Comma is not permitted after the rest element"); }
   var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
-  if (parens > -1) { this.raiseRecoverable(parens, "Parenthesized pattern"); }
+  if (parens > -1) { this.raiseRecoverable(parens, isAssign ? "Assigning to rvalue" : "Parenthesized pattern"); }
 };
 
 pp$9.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
@@ -29017,6 +29027,7 @@ pp$8.adaptDirectivePrologue = function(statements) {
 };
 pp$8.isDirectiveCandidate = function(statement) {
   return (
+    this.options.ecmaVersion >= 5 &&
     statement.type === "ExpressionStatement" &&
     statement.expression.type === "Literal" &&
     typeof statement.expression.value === "string" &&
@@ -29427,7 +29438,8 @@ pp$6.updateContext = function(prevType) {
     { this.exprAllowed = type.beforeExpr; }
 };
 
-// Used to handle egde case when token context could not be inferred correctly in tokenize phase
+// Used to handle egde cases when token context could not be inferred correctly during tokenization phase
+
 pp$6.overrideContext = function(tokenCtx) {
   if (this.curContext() !== tokenCtx) {
     this.context[this.context.length - 1] = tokenCtx;
@@ -30243,15 +30255,6 @@ pp$5.parseProperty = function(isPattern, refDestructuringErrors) {
       }
       return this.finishNode(prop, "RestElement")
     }
-    // To disallow parenthesized identifier via `this.toAssignable()`.
-    if (this.type === types$1.parenL && refDestructuringErrors) {
-      if (refDestructuringErrors.parenthesizedAssign < 0) {
-        refDestructuringErrors.parenthesizedAssign = this.start;
-      }
-      if (refDestructuringErrors.parenthesizedBind < 0) {
-        refDestructuringErrors.parenthesizedBind = this.start;
-      }
-    }
     // Parse argument.
     prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
     // To disallow trailing comma via `this.toAssignable()`.
@@ -32681,7 +32684,7 @@ pp.readWord = function() {
 
 // Acorn is a tiny, fast JavaScript parser written in JavaScript.
 
-var version = "8.7.1";
+var version = "8.8.0";
 
 Parser.acorn = {
   Parser: Parser,
@@ -33300,11 +33303,6 @@ function assetPlugin(config) {
         renderChunk(code, chunk) {
             let match;
             let s;
-            const toRelative = (filename, importer) => {
-                return {
-                    runtime: `new URL(${JSON.stringify(path$n.posix.relative(path$n.dirname(importer), filename))},import.meta.url).href`
-                };
-            };
             // Urls added with JS using e.g.
             // imgElement.src = "__VITE_ASSET__5aa0ddc0__" are using quotes
             // Urls added in CSS that is imported in JS end up like
@@ -33318,7 +33316,7 @@ function assetPlugin(config) {
                 const file = getAssetFilename(hash, config) || this.getFileName(hash);
                 chunk.viteMetadata.importedAssets.add(cleanUrl(file));
                 const filename = file + postfix;
-                const replacement = toOutputFilePathInString(filename, 'asset', chunk.fileName, 'js', config, toRelative);
+                const replacement = toOutputFilePathInString(filename, 'asset', chunk.fileName, 'js', config);
                 const replacementString = typeof replacement === 'string'
                     ? JSON.stringify(replacement).slice(1, -1)
                     : `"+${replacement.runtime}+"`;
@@ -33332,7 +33330,7 @@ function assetPlugin(config) {
                 s = s || (s = new MagicString(code));
                 const [full, hash] = match;
                 const publicUrl = publicAssetUrlMap.get(hash).slice(1);
-                const replacement = toOutputFilePathInString(publicUrl, 'public', chunk.fileName, 'js', config, toRelative);
+                const replacement = toOutputFilePathInString(publicUrl, 'public', chunk.fileName, 'js', config);
                 const replacementString = typeof replacement === 'string'
                     ? JSON.stringify(replacement).slice(1, -1)
                     : `"+${replacement.runtime}+"`;
@@ -33407,6 +33405,9 @@ function fileToDevUrl(id, config) {
 function getAssetFilename(hash, config) {
     return assetHashToFilenameMap.get(config)?.get(hash);
 }
+function getPublicAssetFilename(hash, config) {
+    return publicAssetUrlCache.get(config)?.get(hash);
+}
 function resolveAssetFileNames(config) {
     const output = config.build?.rollupOptions?.output;
     const defaultAssetFileNames = path$n.posix.join(config.build.assetsDir, '[name].[hash][extname]');
@@ -34095,7 +34096,7 @@ function tryResolveFile(file, postfix, options, tryIndex, targetWeb, tryPrefix,
     }
 }
 const idToPkgMap = new Map();
-function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, externalize) {
+function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, externalize, allowLinkedExternal = true) {
     const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
     ssr ?? (ssr = false);
     // split id by last '>' for nested selected packages, for example:
@@ -34179,13 +34180,17 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         if (!externalize) {
             return resolved;
         }
+        // dont external symlink packages
+        if (!allowLinkedExternal && !resolved.id.includes('node_modules')) {
+            return resolved;
+        }
         const resolvedExt = path$n.extname(resolved.id);
         let resolvedId = id;
         if (isDeepImport) {
             // check ext before externalizing - only externalize
             // extension-less imports and explicit .js imports
             if (resolvedExt && !resolved.id.match(/(.js|.mjs|.cjs)$/)) {
-                return;
+                return resolved;
             }
             if (!pkg?.data.exports && path$n.extname(id) !== resolvedExt) {
                 resolvedId += resolvedExt;
@@ -34537,6 +34542,8 @@ const externalTypes = [
     'stylus',
     'pcss',
     'postcss',
+    // wasm
+    'wasm',
     // known SFC types
     'vue',
     'svelte',
@@ -35383,10 +35390,6 @@ function importGlobPlugin(config) {
                 if (server) {
                     const allGlobs = result.matches.map((i) => i.globsResolved);
                     server._importGlobMap.set(id, allGlobs);
-                    result.files.forEach((file) => {
-                        // update watcher
-                        server.watcher.add(dirname(file));
-                    });
                 }
                 return transformStableResult(result.s, id, config);
             }
@@ -35454,6 +35457,10 @@ async function parseImportGlob(code, importer, root, resolveId) {
         }
         if (ast.type === 'SequenceExpression')
             ast = ast.expressions[0];
+        // immediate property access, call expression is nested
+        // import.meta.glob(...)['prop']
+        if (ast.type === 'MemberExpression')
+            ast = ast.object;
         if (ast.type !== 'CallExpression')
             throw err(`Expect CallExpression, got ${ast.type}`);
         if (ast.arguments.length < 1 || ast.arguments.length > 2)
@@ -35461,24 +35468,31 @@ async function parseImportGlob(code, importer, root, resolveId) {
         const arg1 = ast.arguments[0];
         const arg2 = ast.arguments[1];
         const globs = [];
-        if (arg1.type === 'ArrayExpression') {
-            for (const element of arg1.elements) {
-                if (!element)
-                    continue;
-                if (element.type !== 'Literal')
-                    throw err('Could only use literals');
+        const validateLiteral = (element) => {
+            if (!element)
+                return;
+            if (element.type === 'Literal') {
                 if (typeof element.value !== 'string')
                     throw err(`Expected glob to be a string, but got "${typeof element.value}"`);
                 globs.push(element.value);
             }
-        }
-        else if (arg1.type === 'Literal') {
-            if (typeof arg1.value !== 'string')
-                throw err(`Expected glob to be a string, but got "${typeof arg1.value}"`);
-            globs.push(arg1.value);
+            else if (element.type === 'TemplateLiteral') {
+                if (element.expressions.length !== 0) {
+                    throw err(`Expected glob to be a string, but got dynamic template literal`);
+                }
+                globs.push(element.quasis[0].value.raw);
+            }
+            else {
+                throw err('Could only use literals');
+            }
+        };
+        if (arg1.type === 'ArrayExpression') {
+            for (const element of arg1.elements) {
+                validateLiteral(element);
+            }
         }
         else {
-            throw err('Could only use literals');
+            validateLiteral(arg1);
         }
         // arg2
         const options = {};
@@ -35985,14 +35999,18 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
             build.onResolve({
                 // avoid matching windows volume
                 filter: /^[\w@][^:]/
-            }, async ({ path: id, importer }) => {
+            }, async ({ path: id, importer, pluginData }) => {
                 if (moduleListContains(exclude, id)) {
                     return externalUnlessEntry({ path: id });
                 }
                 if (depImports[id]) {
                     return externalUnlessEntry({ path: id });
                 }
-                const resolved = await resolve(id, importer);
+                const resolved = await resolve(id, importer, {
+                    custom: {
+                        depScan: { loader: pluginData?.htmlType?.loader }
+                    }
+                });
                 if (resolved) {
                     if (shouldExternalizeDep(resolved, id)) {
                         return externalUnlessEntry({ path: id });
@@ -36025,9 +36043,9 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
             // should be faster than doing it in the catch-all via js
             // they are done after the bare import resolve because a package name
             // may end with these extensions
-            // css & json
+            // css & json & wasm
             build.onResolve({
-                filter: /\.(css|less|sass|scss|styl|stylus|pcss|postcss|json)$/
+                filter: /\.(css|less|sass|scss|styl|stylus|pcss|postcss|json|wasm)$/
             }, externalUnlessEntry);
             // known asset types
             build.onResolve({
@@ -36137,7 +36155,7 @@ function getDepsOptimizer(config, ssr) {
 }
 async function initDepsOptimizer(config, server) {
     // Non Dev SSR Optimizer
-    const ssr = !!config.build.ssr;
+    const ssr = config.command === 'build' && !!config.build.ssr;
     if (!getDepsOptimizer(config, ssr)) {
         await createDepsOptimizer(config, server);
     }
@@ -36168,7 +36186,7 @@ async function initDevSsrDepsOptimizer(config, server) {
 async function createDepsOptimizer(config, server) {
     const { logger } = config;
     const isBuild = config.command === 'build';
-    const ssr = !!config.build.ssr; // safe as Dev SSR don't use this optimizer
+    const ssr = isBuild && !!config.build.ssr; // safe as Dev SSR don't use this optimizer
     const sessionTimestamp = Date.now().toString();
     const cachedMetadata = loadCachedDepOptimizationMetadata(config, ssr);
     let handle;
@@ -36271,11 +36289,11 @@ async function createDepsOptimizer(config, server) {
         // promises are going to be resolved once a rerun is committed
         depOptimizationProcessingQueue.push(depOptimizationProcessing);
         // Create a new promise for the next rerun, discovered missing
-        // dependencies will be asigned this promise from this point
+        // dependencies will be assigned this promise from this point
         depOptimizationProcessing = newDepOptimizationProcessing();
     }
     async function optimizeNewDeps() {
-        // a succesful completion of the optimizeDeps rerun will end up
+        // a successful completion of the optimizeDeps rerun will end up
         // creating new bundled version of all current and discovered deps
         // in the cache dir and a new metadata info object assigned
         // to _metadata. A fullReload is only issued if the previous bundled
@@ -36384,7 +36402,7 @@ async function createDepsOptimizer(config, server) {
             else {
                 if (newDepsDiscovered) {
                     // There are newly discovered deps, and another rerun is about to be
-                    // excecuted. Avoid the current full reload discarding this rerun result
+                    // executed. Avoid the current full reload discarding this rerun result
                     // We don't resolve the processing promise, as they will be resolved
                     // once a rerun is committed
                     processingResult.cancel();
@@ -36481,7 +36499,7 @@ async function createDepsOptimizer(config, server) {
             src: resolved,
             // Assing a browserHash to this missing dependency that is unique to
             // the current state of known + missing deps. If its optimizeDeps run
-            // doesn't alter the bundled files of previous known dependendencies,
+            // doesn't alter the bundled files of previous known dependencies,
             // we don't need a full reload and this browserHash will be kept
             browserHash: getDiscoveredBrowserHash(metadata.hash, depsFromOptimizedDepInfo(metadata.optimized), depsFromOptimizedDepInfo(metadata.discovered)),
             // loading of this pre-bundled dep needs to await for its processing
@@ -36684,7 +36702,7 @@ const jsMapExtensionRE = /\.js\.map$/i;
  */
 async function optimizeDeps(config, force = config.optimizeDeps.force, asCommand = false) {
     const log = asCommand ? config.logger.info : debug$a;
-    const ssr = !!config.build.ssr;
+    const ssr = config.command === 'build' && !!config.build.ssr;
     const cachedMetadata = loadCachedDepOptimizationMetadata(config, ssr, force, asCommand);
     if (cachedMetadata) {
         return cachedMetadata;
@@ -36819,7 +36837,8 @@ function depsLogString(qualifiedIds) {
  * Internally, Vite uses this function to prepare a optimizeDeps run. When Vite starts, we can get
  * the metadata and start the server without waiting for the optimizeDeps processing to be completed
  */
-async function runOptimizeDeps(resolvedConfig, depsInfo, ssr = !!resolvedConfig.build.ssr) {
+async function runOptimizeDeps(resolvedConfig, depsInfo, ssr = resolvedConfig.command === 'build' &&
+    !!resolvedConfig.build.ssr) {
     const isBuild = resolvedConfig.command === 'build';
     const config = {
         ...resolvedConfig,
@@ -37045,7 +37064,7 @@ function newDepOptimizationProcessing() {
 function depsFromOptimizedDepInfo(depsInfo) {
     return Object.fromEntries(Object.entries(depsInfo).map((d) => [d[0], d[1].src]));
 }
-function getOptimizedDepPath(id, config, ssr = !!config.build.ssr) {
+function getOptimizedDepPath(id, config, ssr) {
     return normalizePath$3(path$n.resolve(getDepsCacheDir(config, ssr), flattenId(id) + '.js'));
 }
 function getDepsCacheSuffix(config, ssr) {
@@ -37232,7 +37251,7 @@ function needsInterop(config, ssr, id, exportsData, output) {
         return true;
     }
     if (output) {
-        // if a peer dependency used require() on a ESM dependency, esbuild turns the
+        // if a peer dependency used require() on an ESM dependency, esbuild turns the
         // ESM dependency's entry chunk into a single default export... detect
         // such cases by checking exports mismatch, and force interop.
         const generatedExports = output.exports;
@@ -37975,22 +37994,55 @@ function shouldExternalizeForSSR(id, config) {
     return isSsrExternal(id);
 }
 function createIsConfiguredAsSsrExternal(config) {
-    const { ssr } = config;
+    const { ssr, root } = config;
     const noExternal = ssr?.noExternal;
     const noExternalFilter = noExternal !== 'undefined' &&
         typeof noExternal !== 'boolean' &&
         createFilter(undefined, noExternal, { resolve: false });
+    const resolveOptions = {
+        root,
+        preserveSymlinks: config.resolve.preserveSymlinks,
+        isProduction: false,
+        isBuild: true
+    };
+    const isExternalizable = (id, configuredAsExternal) => {
+        if (!bareImportRE.test(id) || id.includes('\0')) {
+            return false;
+        }
+        try {
+            return !!tryNodeResolve(id, undefined, resolveOptions, ssr?.target === 'webworker', undefined, true, 
+            // try to externalize, will return undefined or an object without
+            // a external flag if it isn't externalizable
+            true, 
+            // Allow linked packages to be externalized if they are explicitly
+            // configured as external
+            !!configuredAsExternal)?.external;
+        }
+        catch (e) {
+            // may be an invalid import that's resolved by a plugin
+            return false;
+        }
+    };
     // Returns true if it is configured as external, false if it is filtered
     // by noExternal and undefined if it isn't affected by the explicit config
     return (id) => {
         const { ssr } = config;
         if (ssr) {
+            if (
+            // If this id is defined as external, force it as external
+            // Note that individual package entries are allowed in ssr.external
+            ssr.external?.includes(id)) {
+                return true;
+            }
             const pkgName = getNpmPackageName(id);
             if (!pkgName) {
-                return undefined;
+                return isExternalizable(id);
             }
-            if (ssr.external?.includes(pkgName)) {
-                return true;
+            if (
+            // A package name in ssr.external externalizes every
+            // externalizable package entry
+            ssr.external?.includes(pkgName)) {
+                return isExternalizable(id, true);
             }
             if (typeof noExternal === 'boolean') {
                 return !noExternal;
@@ -37999,34 +38051,19 @@ function createIsConfiguredAsSsrExternal(config) {
                 return false;
             }
         }
-        return undefined;
+        return isExternalizable(id);
     };
 }
 function createIsSsrExternal(config) {
     const processedIds = new Map();
-    const { ssr, root } = config;
     const isConfiguredAsExternal = createIsConfiguredAsSsrExternal(config);
-    const resolveOptions = {
-        root,
-        preserveSymlinks: config.resolve.preserveSymlinks,
-        isProduction: false,
-        isBuild: true
-    };
-    const isValidPackageEntry = (id) => {
-        if (!bareImportRE.test(id) || id.includes('\0')) {
-            return false;
-        }
-        return !!tryNodeResolve(id, undefined, resolveOptions, ssr?.target === 'webworker', undefined, true, true // try to externalize, will return undefined if not possible
-        );
-    };
     return (id) => {
         if (processedIds.has(id)) {
             return processedIds.get(id);
         }
         let external = false;
         if (!id.startsWith('.') && !path$n.isAbsolute(id)) {
-            external =
-                isBuiltin(id) || (isConfiguredAsExternal(id) ?? isValidPackageEntry(id));
+            external = isBuiltin(id) || isConfiguredAsExternal(id);
         }
         processedIds.set(id, external);
         return external;
@@ -39500,32 +39537,36 @@ function serveStaticMiddleware(dir, server) {
             isInternalRequest(req.url)) {
             return next();
         }
-        const url = decodeURIComponent(req.url);
+        const url = new URL(req.url, 'http://example.com');
+        const pathname = decodeURIComponent(url.pathname);
         // apply aliases to static requests as well
-        let redirected;
+        let redirectedPathname;
         for (const { find, replacement } of server.config.resolve.alias) {
-            const matches = typeof find === 'string' ? url.startsWith(find) : find.test(url);
+            const matches = typeof find === 'string'
+                ? pathname.startsWith(find)
+                : find.test(pathname);
             if (matches) {
-                redirected = url.replace(find, replacement);
+                redirectedPathname = pathname.replace(find, replacement);
                 break;
             }
         }
-        if (redirected) {
+        if (redirectedPathname) {
             // dir is pre-normalized to posix style
-            if (redirected.startsWith(dir)) {
-                redirected = redirected.slice(dir.length);
+            if (redirectedPathname.startsWith(dir)) {
+                redirectedPathname = redirectedPathname.slice(dir.length);
             }
         }
-        const resolvedUrl = redirected || url;
-        let fileUrl = path$n.resolve(dir, resolvedUrl.replace(/^\//, ''));
-        if (resolvedUrl.endsWith('/') && !fileUrl.endsWith('/')) {
+        const resolvedPathname = redirectedPathname || pathname;
+        let fileUrl = path$n.resolve(dir, resolvedPathname.replace(/^\//, ''));
+        if (resolvedPathname.endsWith('/') && !fileUrl.endsWith('/')) {
             fileUrl = fileUrl + '/';
         }
         if (!ensureServingAccess(fileUrl, server, res, next)) {
             return;
         }
-        if (redirected) {
-            req.url = encodeURIComponent(redirected);
+        if (redirectedPathname) {
+            url.pathname = encodeURIComponent(redirectedPathname);
+            req.url = url.href.slice(url.origin.length);
         }
         serve(req, res, next);
     };
@@ -39534,20 +39575,22 @@ function serveRawFsMiddleware(server) {
     const serveFromRoot = sirv('/', sirvOptions(server.config.server.headers));
     // Keep the named function. The name is visible in debug logs via `DEBUG=connect:dispatcher ...`
     return function viteServeRawFsMiddleware(req, res, next) {
-        let url = decodeURIComponent(req.url);
+        const url = new URL(req.url, 'http://example.com');
         // In some cases (e.g. linked monorepos) files outside of root will
         // reference assets that are also out of served root. In such cases
         // the paths are rewritten to `/@fs/` prefixed paths and must be served by
         // searching based from fs root.
-        if (url.startsWith(FS_PREFIX)) {
+        if (url.pathname.startsWith(FS_PREFIX)) {
+            const pathname = decodeURIComponent(url.pathname);
             // restrict files outside of `fs.allow`
-            if (!ensureServingAccess(slash$1(path$n.resolve(fsPathFromId(url))), server, res, next)) {
+            if (!ensureServingAccess(slash$1(path$n.resolve(fsPathFromId(pathname))), server, res, next)) {
                 return;
             }
-            url = url.slice(FS_PREFIX.length);
+            let newPathname = pathname.slice(FS_PREFIX.length);
             if (isWindows$4)
-                url = url.replace(/^[A-Z]:/i, '');
-            req.url = encodeURIComponent(url);
+                newPathname = newPathname.replace(/^[A-Z]:/i, '');
+            url.pathname = encodeURIComponent(newPathname);
+            req.url = url.href.slice(url.origin.length);
             serveFromRoot(req, res, next);
         }
         else {
@@ -39577,7 +39620,7 @@ function ensureServingAccess(url, server, res, next) {
         const hintMessage = `
 ${server.config.server.fs.allow.map((i) => `- ${i}`).join('\n')}
 
-Refer to docs https://vitejs.dev/config/#server-fs-allow for configurations and more details.`;
+Refer to docs https://vitejs.dev/config/server-options.html#server-fs-allow for configurations and more details.`;
         server.config.logger.error(urlMessage);
         server.config.logger.warnOnce(hintMessage + '\n');
         res.statusCode = 403;
@@ -40990,7 +41033,7 @@ function polyfill() {
     }
 }
 
-const htmlProxyRE$1 = /\?html-proxy=?[&inline\-css]*&index=(\d+)\.(js|css)$/;
+const htmlProxyRE$1 = /\?html-proxy=?(?:&inline-css)?&index=(\d+)\.(js|css)$/;
 const inlineCSSRE$1 = /__VITE_INLINE_CSS__([a-z\d]{8}_\d+)__/g;
 // Do not allow preceding '.', but do allow preceding '...' for spread operations
 const inlineImportRE = /(?<!(?<!\.\.)\.)\bimport\s*\(("([^"]|(?<=\\)")*"|'([^']|(?<=\\)')*')\)/g;
@@ -41056,7 +41099,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await import('./dep-7d66befd.js').then(function (n) { return n.c; });
+    const { parse, transform } = await import('./dep-f135d593.js').then(function (n) { return n.c; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -41218,7 +41261,10 @@ function buildHtmlPlugin(config) {
                                 // assetsUrl may be encodeURI
                                 const url = decodeURI(p.value.content);
                                 if (!isExcludedUrl(url)) {
-                                    if (node.tag === 'link' && isCSSRequest(url)) {
+                                    if (node.tag === 'link' &&
+                                        isCSSRequest(url) &&
+                                        // should not be converted if following attributes are present (#6748)
+                                        !node.props.some((p) => p.name === 'media' || p.name === 'disabled')) {
                                         // CSS references, convert to import
                                         const importExpression = `\nimport ${JSON.stringify(url)}`;
                                         styleUrls.push({
@@ -41402,14 +41448,16 @@ function buildHtmlPlugin(config) {
             for (const [id, html] of processedHtml) {
                 const relativeUrlPath = path$n.posix.relative(config.root, id);
                 const assetsBase = getBaseInHTML(relativeUrlPath, config);
-                const toOutputAssetFilePath = (filename) => {
+                const toOutputFilePath = (filename, type) => {
                     if (isExternalUrl(filename)) {
                         return filename;
                     }
                     else {
-                        return toOutputFilePathInHtml(filename, 'asset', relativeUrlPath, 'html', config, (filename, importer) => assetsBase + filename);
+                        return toOutputFilePathInHtml(filename, type, relativeUrlPath, 'html', config, (filename, importer) => assetsBase + filename);
                     }
                 };
+                const toOutputAssetFilePath = (filename) => toOutputFilePath(filename, 'asset');
+                const toOutputPublicAssetFilePath = (filename) => toOutputFilePath(filename, 'public');
                 const isAsync = isAsyncScriptMap.get(config).get(id);
                 let result = html;
                 // find corresponding entry chunk
@@ -41474,6 +41522,9 @@ function buildHtmlPlugin(config) {
                 result = result.replace(assetUrlRE, (_, fileHash, postfix = '') => {
                     return (toOutputAssetFilePath(getAssetFilename(fileHash, config)) + postfix);
                 });
+                result = result.replace(publicAssetUrlRE, (_, fileHash) => {
+                    return normalizePath$3(toOutputPublicAssetFilePath(getPublicAssetFilename(fileHash, config)));
+                });
                 if (chunk && canInlineEntry) {
                     // all imports from entry have been inlined to html, prevent rollup from outputting it
                     delete bundle[chunk.fileName];
@@ -41956,7 +42007,7 @@ function cssPostPlugin(config) {
                 return chunkCSS;
             }
             function ensureFileExt(name, ext) {
-                return path$n.format({ ...path$n.parse(name), base: undefined, ext });
+                return normalizePath$3(path$n.format({ ...path$n.parse(name), base: undefined, ext }));
             }
             if (config.build.cssCodeSplit) {
                 if (isPureCssChunk) {
@@ -42186,7 +42237,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-adbb28b2.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-3811dadb.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -42497,17 +42548,23 @@ async function minifyCSS(css, config) {
     }
 }
 function resolveEsbuildMinifyOptions(options) {
+    const base = {
+        logLevel: options.logLevel,
+        logLimit: options.logLimit,
+        logOverride: options.logOverride
+    };
     if (options.minifyIdentifiers != null ||
         options.minifySyntax != null ||
         options.minifyWhitespace != null) {
         return {
+            ...base,
             minifyIdentifiers: options.minifyIdentifiers ?? true,
             minifySyntax: options.minifySyntax ?? true,
             minifyWhitespace: options.minifyWhitespace ?? true
         };
     }
     else {
-        return { minify: true };
+        return { ...base, minify: true };
     }
 }
 async function hoistAtRules(css) {
@@ -43116,7 +43173,7 @@ function assetImportMetaUrlPlugin(config) {
                             // target so we use the global location here. It can be
                             // window.location or self.location in case it is used in a Web Worker.
                             // @see https://developer.mozilla.org/en-US/docs/Web/API/Window/self
-                            s.overwrite(index, index + exp.length, `new URL((import.meta.glob(${pattern}, { eager: true, import: 'default' }))[${rawUrl}], self.location)`, { contentOnly: true });
+                            s.overwrite(index, index + exp.length, `new URL((import.meta.glob(${pattern}, { eager: true, import: 'default', as: 'url' }))[${rawUrl}], self.location)`, { contentOnly: true });
                             continue;
                         }
                     }
@@ -43361,10 +43418,11 @@ async function doBuild(inlineConfig = {}) {
                     `This is deprecated and will override all Vite.js default output options. ` +
                     `Please use "rollupOptions.output" instead.`);
             }
-            const ssrWorkerBuild = ssr && config.ssr?.target !== 'webworker';
-            const cjsSsrBuild = ssr && config.ssr?.format === 'cjs';
+            const ssrNodeBuild = ssr && config.ssr.target === 'node';
+            const ssrWorkerBuild = ssr && config.ssr.target === 'webworker';
+            const cjsSsrBuild = ssr && config.ssr.format === 'cjs';
             const format = output.format || (cjsSsrBuild ? 'cjs' : 'es');
-            const jsExt = ssrWorkerBuild || libOptions
+            const jsExt = ssrNodeBuild || libOptions
                 ? resolveOutputJsExtension(format, getPkgJson(config.root)?.type)
                 : 'js';
             return {
@@ -43649,7 +43707,7 @@ function wrapSsrTransform(fn) {
 function injectSsrFlag(options) {
     return { ...(options ?? {}), ssr: true };
 }
-function toOutputFilePathInString(filename, type, hostId, hostType, config, toRelative) {
+function toOutputFilePathInString(filename, type, hostId, hostType, config, toRelative = toImportMetaURLBasedRelativePath) {
     const { renderBuiltUrl } = config.experimental;
     let relative = config.base === '' || config.base === './';
     if (renderBuiltUrl) {
@@ -43676,6 +43734,11 @@ function toOutputFilePathInString(filename, type, hostId, hostType, config, toRe
     }
     return config.base + filename;
 }
+function toImportMetaURLBasedRelativePath(filename, importer) {
+    return {
+        runtime: `new URL(${JSON.stringify(path$n.posix.relative(path$n.dirname(importer), filename))},import.meta.url).href`
+    };
+}
 function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config, toRelative) {
     const { renderBuiltUrl } = config.experimental;
     let relative = config.base === '' || config.base === './';
@@ -50276,7 +50339,8 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         if (dep[0] !== '.' && dep[0] !== '/') {
             return nodeImport(dep, mod.file, resolveOptions);
         }
-        dep = unwrapId(dep);
+        // convert to rollup URL because `pendingImports`, `moduleGraph.urlToModuleMap` requires that
+        dep = unwrapId(dep).replace(NULL_BYTE_PLACEHOLDER, '\0');
         if (!isCircular(dep) && !pendingImports.get(dep)?.some(isCircular)) {
             pendingDeps.push(dep);
             if (pendingDeps.length === 1) {
@@ -50318,7 +50382,7 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     try {
         // eslint-disable-next-line @typescript-eslint/no-empty-function
         const AsyncFunction = async function () { }.constructor;
-        const initModule = new AsyncFunction(`global`, ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey, result.code + `\n//# sourceURL=${mod.url}`);
+        const initModule = new AsyncFunction(`global`, ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey, '"use strict";' + result.code + `\n//# sourceURL=${mod.url}`);
         await initModule(context.global, ssrModule, ssrImportMeta, ssrImport, ssrDynamicImport, ssrExportAll);
     }
     catch (e) {
@@ -50399,7 +50463,7 @@ async function nodeImport(id, importer, resolveOptions) {
 }
 // rollup-style default import interop for cjs
 function proxyESM(mod) {
-    // This is the only sensible option when the exports object is a primitve
+    // This is the only sensible option when the exports object is a primitive
     if (isPrimitive(mod))
         return { default: mod };
     let defaultExport = 'default' in mod ? mod.default : mod;
@@ -53520,11 +53584,11 @@ function initAsClient(websocket, address, protocols, options) {
     ? parsedUrl.hostname.slice(1, -1)
     : parsedUrl.hostname;
   opts.headers = {
+    ...opts.headers,
     'Sec-WebSocket-Version': opts.protocolVersion,
     'Sec-WebSocket-Key': key,
     Connection: 'Upgrade',
-    Upgrade: 'websocket',
-    ...opts.headers
+    Upgrade: 'websocket'
   };
   opts.path = parsedUrl.pathname + parsedUrl.search;
   opts.timeout = opts.handshakeTimeout;
@@ -53578,8 +53642,11 @@ function initAsClient(websocket, address, protocols, options) {
 
   if (opts.followRedirects) {
     if (websocket._redirects === 0) {
+      websocket._originalUnixSocket = isUnixSocket;
       websocket._originalSecure = isSecure;
-      websocket._originalHost = parsedUrl.host;
+      websocket._originalHostOrSocketPath = isUnixSocket
+        ? opts.socketPath
+        : parsedUrl.host;
 
       const headers = options && options.headers;
 
@@ -53595,7 +53662,13 @@ function initAsClient(websocket, address, protocols, options) {
         }
       }
     } else if (websocket.listenerCount('redirect') === 0) {
-      const isSameHost = parsedUrl.host === websocket._originalHost;
+      const isSameHost = isUnixSocket
+        ? websocket._originalUnixSocket
+          ? opts.socketPath === websocket._originalHostOrSocketPath
+          : false
+        : websocket._originalUnixSocket
+        ? false
+        : parsedUrl.host === websocket._originalHostOrSocketPath;
 
       if (!isSameHost || (websocket._originalSecure && !isSecure)) {
         //
@@ -56970,7 +57043,7 @@ function proxyMiddleware(httpServer, options, config) {
                     timestamp: true,
                     error: err
                 });
-                if (!res.writableEnded) {
+                if (!res.headersSent && !res.writableEnded) {
                     res
                         .writeHead(500, {
                         'Content-Type': 'text/plain'
@@ -57389,9 +57462,9 @@ function transformMiddleware(server) {
                 }
                 // We don't need to log an error in this case, the request
                 // is outdated because new dependencies were discovered and
-                // the new pre-bundle dependendencies have changed.
+                // the new pre-bundle dependencies have changed.
                 // A full-page reload has been issued, and these old requests
-                // can't be properly fullfilled. This isn't an unexpected
+                // can't be properly fulfilled. This isn't an unexpected
                 // error but a normal part of the missing deps discovery flow
                 return;
             }
@@ -57766,10 +57839,14 @@ class ModuleGraph {
         url = removeImportQuery(removeTimestampQuery(url));
         const resolved = await this.resolveId(url, !!ssr);
         const resolvedId = resolved?.id || url;
-        const ext = extname$1(cleanUrl(resolvedId));
-        const { pathname, search, hash } = parse$k(url);
-        if (ext && !pathname.endsWith(ext)) {
-            url = pathname + ext + (search || '') + (hash || '');
+        if (url !== resolvedId &&
+            !url.includes('\0') &&
+            !url.startsWith(`virtual:`)) {
+            const ext = extname$1(cleanUrl(resolvedId));
+            const { pathname, search, hash } = new URL(url, 'relative://');
+            if (ext && !pathname.endsWith(ext)) {
+                url = pathname + ext + search + hash;
+            }
         }
         return [url, resolvedId, resolved?.meta];
     }
@@ -59810,14 +59887,6 @@ function emitSourcemapForWorkerEntry(config, query, chunk) {
     }
     return chunk;
 }
-// TODO:base review why we aren't using import.meta.url here
-function toStaticRelativePath(filename, importer) {
-    let outputFilepath = path$n.posix.relative(path$n.dirname(importer), filename);
-    if (!outputFilepath.startsWith('.')) {
-        outputFilepath = './' + outputFilepath;
-    }
-    return outputFilepath;
-}
 const workerAssetUrlRE = /__VITE_WORKER_ASSET__([a-z\d]{8})__/g;
 function encodeWorkerAssetFileName(fileName, workerCache) {
     const { fileNameHash } = workerCache;
@@ -59973,7 +60042,7 @@ function webWorkerPlugin(config) {
                 while ((match = workerAssetUrlRE.exec(code))) {
                     const [full, hash] = match;
                     const filename = fileNameHash.get(hash);
-                    const replacement = toOutputFilePathInString(filename, 'asset', chunk.fileName, 'js', config, toStaticRelativePath);
+                    const replacement = toOutputFilePathInString(filename, 'asset', chunk.fileName, 'js', config);
                     const replacementString = typeof replacement === 'string'
                         ? JSON.stringify(replacement).slice(1, -1)
                         : `"+${replacement.runtime}+"`;
@@ -61921,7 +61990,13 @@ function dynamicImportVarsPlugin(config) {
                 s || (s = new MagicString(source));
                 let result;
                 try {
-                    result = await transformDynamicImport(source.slice(start, end), importer, resolve);
+                    // When import string is using backticks, es-module-lexer `end` captures
+                    // until the closing parenthesis, instead of the closing backtick.
+                    // There may be inline comments between the backtick and the closing
+                    // parenthesis, so we manually remove them for now.
+                    // See https://github.com/guybedford/es-module-lexer/issues/118
+                    const importSource = removeComments(source.slice(start, end)).trim();
+                    result = await transformDynamicImport(importSource, importer, resolve);
                 }
                 catch (error) {
                     if (warnOnError) {
@@ -61998,7 +62073,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
         wasmFallbackPlugin(),
         definePlugin(config),
         cssPostPlugin(config),
-        config.build.ssr ? ssrRequireHookPlugin(config) : null,
+        isBuild && config.build.ssr ? ssrRequireHookPlugin(config) : null,
         isBuild && buildHtmlPlugin(config),
         workerImportMetaUrlPlugin(config),
         ...buildPlugins.pre,
@@ -62335,6 +62410,23 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     // user config may provide an alternative mode. But --mode has a higher priority
     mode = inlineConfig.mode || config.mode || mode;
     configEnv.mode = mode;
+    // Some plugins that aren't intended to work in the bundling of workers (doing post-processing at build time for example).
+    // And Plugins may also have cached that could be corrupted by being used in these extra rollup calls.
+    // So we need to separate the worker plugin from the plugin that vite needs to run.
+    const rawWorkerUserPlugins = (await asyncFlatten(config.worker?.plugins || [])).filter((p) => {
+        if (!p) {
+            return false;
+        }
+        else if (!p.apply) {
+            return true;
+        }
+        else if (typeof p.apply === 'function') {
+            return p.apply({ ...config, mode }, configEnv);
+        }
+        else {
+            return p.apply === command;
+        }
+    });
     // resolve plugins
     const rawUserPlugins = (await asyncFlatten(config.plugins || [])).filter((p) => {
         if (!p) {
@@ -62351,12 +62443,6 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
         }
     });
     const [prePlugins, normalPlugins, postPlugins] = sortUserPlugins(rawUserPlugins);
-    // resolve worker
-    const resolvedWorkerOptions = {
-        format: config.worker?.format || 'iife',
-        plugins: [],
-        rollupOptions: config.worker?.rollupOptions || {}
-    };
     // run config hooks
     const userPlugins = [...prePlugins, ...normalPlugins, ...postPlugins];
     for (const p of userPlugins) {
@@ -62475,8 +62561,29 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     const middlewareMode = config?.server?.middlewareMode;
     const optimizeDeps = config.optimizeDeps || {};
     const BASE_URL = resolvedBase;
-    const resolved = {
-        ...config,
+    // resolve worker
+    let workerConfig = mergeConfig({}, config);
+    const [workerPrePlugins, workerNormalPlugins, workerPostPlugins] = sortUserPlugins(rawWorkerUserPlugins);
+    // run config hooks
+    const workerUserPlugins = [
+        ...workerPrePlugins,
+        ...workerNormalPlugins,
+        ...workerPostPlugins
+    ];
+    for (const p of workerUserPlugins) {
+        if (p.config) {
+            const res = await p.config(workerConfig, configEnv);
+            if (res) {
+                workerConfig = mergeConfig(workerConfig, res);
+            }
+        }
+    }
+    const resolvedWorkerOptions = {
+        format: workerConfig.worker?.format || 'iife',
+        plugins: [],
+        rollupOptions: workerConfig.worker?.rollupOptions || {}
+    };
+    const resolvedConfig = {
         configFile: configFile ? normalizePath$3(configFile) : undefined,
         configFileDependencies: configFileDependencies.map((name) => normalizePath$3(path$n.resolve(name))),
         inlineConfig,
@@ -62524,6 +62631,23 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
             ...config.experimental
         }
     };
+    const resolved = {
+        ...config,
+        ...resolvedConfig
+    };
+    resolved.plugins = await resolvePlugins(resolved, prePlugins, normalPlugins, postPlugins);
+    const workerResolved = {
+        ...workerConfig,
+        ...resolvedConfig,
+        isWorker: true,
+        mainConfig: resolved
+    };
+    resolvedConfig.worker.plugins = await resolvePlugins(workerResolved, workerPrePlugins, workerNormalPlugins, workerPostPlugins);
+    // call configResolved hooks
+    await Promise.all(userPlugins
+        .map((p) => p.configResolved?.(resolved))
+        .concat(resolvedConfig.worker.plugins.map((p) => p.configResolved?.(workerResolved))));
+    // validate config
     if (middlewareMode === 'ssr') {
         logger.warn(picocolors.exports.yellow(`Setting server.middlewareMode to 'ssr' is deprecated, set server.middlewareMode to \`true\`${config.appType === 'custom' ? '' : ` and appType to 'custom'`} instead`));
     }
@@ -62536,21 +62660,6 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
         resolved.optimizeDeps.force = true;
         logger.warn(picocolors.exports.yellow(`server.force is deprecated, use optimizeDeps.force instead`));
     }
-    // Some plugins that aren't intended to work in the bundling of workers (doing post-processing at build time for example).
-    // And Plugins may also have cached that could be corrupted by being used in these extra rollup calls.
-    // So we need to separate the worker plugin from the plugin that vite needs to run.
-    const [workerPrePlugins, workerNormalPlugins, workerPostPlugins] = sortUserPlugins(config.worker?.plugins);
-    const workerResolved = {
-        ...resolved,
-        isWorker: true,
-        mainConfig: resolved
-    };
-    resolved.worker.plugins = await resolvePlugins(workerResolved, workerPrePlugins, workerNormalPlugins, workerPostPlugins);
-    // call configResolved worker plugins hooks
-    await Promise.all(resolved.worker.plugins.map((p) => p.configResolved?.(workerResolved)));
-    resolved.plugins = await resolvePlugins(resolved, prePlugins, normalPlugins, postPlugins);
-    // call configResolved hooks
-    await Promise.all(userPlugins.map((p) => p.configResolved?.(resolved)));
     if (process.env.DEBUG) {
         debug(`using resolved config: %O`, {
             ...resolved,
@@ -62776,13 +62885,15 @@ async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
     // with --experimental-loader themselves, we have to do a hack here:
     // write it to disk, load it with native Node ESM, then delete the file.
     if (isESM) {
-        const fileUrl = pathToFileURL(fileName);
-        fs$l.writeFileSync(fileName + '.mjs', bundledCode);
+        const fileBase = `${fileName}.timestamp-${Date.now()}`;
+        const fileNameTmp = `${fileBase}.mjs`;
+        const fileUrl = `${pathToFileURL(fileBase)}.mjs`;
+        fs$l.writeFileSync(fileNameTmp, bundledCode);
         try {
-            return (await dynamicImport(`${fileUrl}.mjs?t=${Date.now()}`)).default;
+            return (await dynamicImport(fileUrl)).default;
         }
         finally {
-            fs$l.unlinkSync(fileName + '.mjs');
+            fs$l.unlinkSync(fileNameTmp);
         }
     }
     // for cjs, we can register a custom loader via `_require.extensions`