vite 3.0.0 → 3.0.3

package/dist/node/chunks/{dep-561c5231.js → dep-c6273c7a.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) {
@@ -12423,7 +12426,6 @@ function stripBomTag(content) {
     }
     return content;
 }
-const isTS = (filename) => /\.[cm]?ts$/.test(filename);
 const windowsDrivePathPrefixRE = /^[A-Za-z]:[/\\]/;
 /**
  * path.isAbsolute also returns true for drive relative paths on windows (e.g. /something)
@@ -13245,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
@@ -13330,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 = {
@@ -13339,7 +13344,11 @@ function esbuildPlugin(options = {}) {
         minifyIdentifiers: false,
         minifySyntax: false,
         minifyWhitespace: false,
-        treeShaking: false
+        treeShaking: false,
+        // keepNames is not needed when minify is disabled.
+        // Also transforming multiple times with keepNames enabled breaks
+        // tree-shaking. (#9164)
+        keepNames: false
     };
     return {
         name: 'vite:esbuild',
@@ -13434,10 +13443,19 @@ function resolveEsbuildTranspileOptions(config, format) {
     // pure annotations and break tree-shaking
     // https://github.com/vuejs/core/issues/2860#issuecomment-926882793
     const isEsLibBuild = config.build.lib && format === 'es';
+    const esbuildOptions = config.esbuild || {};
     const options = {
-        ...config.esbuild,
+        ...esbuildOptions,
         target: target || undefined,
-        format: rollupToEsbuildFormatMap[format]
+        format: rollupToEsbuildFormatMap[format],
+        // the final build should always support dynamic import and import.meta.
+        // if they need to be polyfilled, plugin-legacy should be used.
+        // plugin-legacy detects these two features when checking for modern code.
+        supported: {
+            'dynamic-import': true,
+            'import-meta': true,
+            ...esbuildOptions.supported
+        }
     };
     // If no minify, disable all minify options
     if (!minify) {
@@ -13551,16 +13569,19 @@ 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
         initTSConfck(server.config).finally(() => {
-            // force full reload
-            server.ws.send({
-                type: 'full-reload',
-                path: '*'
-            });
+            // server may not be available if vite config is updated at the same time
+            if (server) {
+                // force full reload
+                server.ws.send({
+                    type: 'full-reload',
+                    path: '*'
+                });
+            }
         });
     }
 }
@@ -33285,11 +33306,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
@@ -33303,7 +33319,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}+"`;
@@ -33317,7 +33333,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}+"`;
@@ -33902,6 +33918,16 @@ function resolvePlugin(resolveOptions) {
                     return res;
                 }
             }
+            // drive relative fs paths (only windows)
+            if (isWindows$4 && id.startsWith('/')) {
+                const basedir = importer ? path$n.dirname(importer) : process.cwd();
+                const fsPath = path$n.resolve(basedir, id);
+                if ((res = tryFsResolve(fsPath, options))) {
+                    isDebug$4 &&
+                        debug$c(`[drive-relative] ${picocolors.exports.cyan(id)} -> ${picocolors.exports.dim(res)}`);
+                    return res;
+                }
+            }
             // absolute fs paths
             if (isNonDriveRelativeAbsolutePath(id) &&
                 (res = tryFsResolve(id, options))) {
@@ -34070,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:
@@ -34154,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;
@@ -34512,6 +34542,8 @@ const externalTypes = [
     'stylus',
     'pcss',
     'postcss',
+    // wasm
+    'wasm',
     // known SFC types
     'vue',
     'svelte',
@@ -35429,6 +35461,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)
@@ -35960,14 +35996,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 });
@@ -36000,9 +36040,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({
@@ -36112,7 +36152,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);
     }
@@ -36143,7 +36183,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;
@@ -36246,11 +36286,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
@@ -36359,7 +36399,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();
@@ -36456,7 +36496,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
@@ -36659,7 +36699,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;
@@ -36794,7 +36834,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,
@@ -37020,7 +37061,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) {
@@ -37207,7 +37248,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;
@@ -37950,54 +37991,70 @@ 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;
+        }
+        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;
+    };
     // 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 (ssr.external?.includes(id)) {
+            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 isExternalizable(id);
+            }
+            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;
             }
-            if (noExternalFilter && !noExternalFilter(id)) {
+            if (noExternalFilter && !noExternalFilter(pkgName)) {
                 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;
@@ -39471,32 +39528,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);
     };
@@ -39505,20 +39566,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 {
@@ -39548,7 +39611,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;
@@ -40961,7 +41024,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;
@@ -41027,7 +41090,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await import('./dep-f2ffe191.js').then(function (n) { return n.c; });
+    const { parse, transform } = await import('./dep-7f3e64a3.js').then(function (n) { return n.c; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -42157,7 +42220,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-eb5668bc.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-676c6c22.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -42468,17 +42531,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) {
@@ -43353,10 +43422,10 @@ async function doBuild(inlineConfig = {}) {
                     ? `[name].${jsExt}`
                     : libOptions
                         ? resolveLibFilename(libOptions, format, config.root, jsExt)
-                        : path$n.posix.join(options.assetsDir, `[name].[hash].js`),
+                        : path$n.posix.join(options.assetsDir, `[name].[hash].${jsExt}`),
                 chunkFileNames: libOptions
                     ? `[name].[hash].${jsExt}`
-                    : path$n.posix.join(options.assetsDir, `[name].[hash].js`),
+                    : path$n.posix.join(options.assetsDir, `[name].[hash].${jsExt}`),
                 assetFileNames: libOptions
                     ? `[name].[ext]`
                     : path$n.posix.join(options.assetsDir, `[name].[hash].[ext]`),
@@ -43620,7 +43689,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) {
@@ -43647,6 +43716,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 === './';
@@ -50247,7 +50321,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) {
@@ -50289,7 +50364,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) {
@@ -50370,7 +50445,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;
@@ -53491,11 +53566,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;
@@ -53549,8 +53624,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;
 
@@ -53566,7 +53644,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)) {
         //
@@ -56933,16 +57017,29 @@ function proxyMiddleware(httpServer, options, config) {
             opts = { target: opts, changeOrigin: true };
         }
         const proxy = httpProxy.createProxyServer(opts);
-        proxy.on('error', (err, req, res) => {
-            config.logger.error(`${picocolors.exports.red(`http proxy error:`)}\n${err.stack}`, {
-                timestamp: true,
-                error: err
-            });
-            res
-                .writeHead(500, {
-                'Content-Type': 'text/plain'
-            })
-                .end();
+        proxy.on('error', (err, req, originalRes) => {
+            // When it is ws proxy, res is net.Socket
+            const res = originalRes;
+            if ('req' in res) {
+                config.logger.error(`${picocolors.exports.red(`http proxy error:`)}\n${err.stack}`, {
+                    timestamp: true,
+                    error: err
+                });
+                if (!res.headersSent && !res.writableEnded) {
+                    res
+                        .writeHead(500, {
+                        'Content-Type': 'text/plain'
+                    })
+                        .end();
+                }
+            }
+            else {
+                config.logger.error(`${picocolors.exports.red(`ws proxy error:`)}\n${err.stack}`, {
+                    timestamp: true,
+                    error: err
+                });
+                res.end();
+            }
         });
         if (opts.configure) {
             opts.configure(proxy, opts);
@@ -57347,9 +57444,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;
             }
@@ -57724,10 +57821,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];
     }
@@ -59768,14 +59869,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;
@@ -59931,7 +60024,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}+"`;
@@ -61879,7 +61972,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) {
@@ -61956,7 +62055,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,
@@ -62293,6 +62392,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) {
@@ -62309,12 +62425,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) {
@@ -62433,8 +62543,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,
@@ -62482,6 +62613,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`));
     }
@@ -62494,21 +62642,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,
@@ -62590,7 +62723,6 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
     const start = performance.now();
     const getTime = () => `${(performance.now() - start).toFixed(2)}ms`;
     let resolvedPath;
-    let dependencies = [];
     if (configFile) {
         // explicit config path is always resolved from cwd
         resolvedPath = path$n.resolve(configFile);
@@ -62626,41 +62758,9 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         catch (e) { }
     }
     try {
-        let userConfig;
-        if (isESM) {
-            const fileUrl = pathToFileURL(resolvedPath);
-            const bundled = await bundleConfigFile(resolvedPath, true);
-            dependencies = bundled.dependencies;
-            if (isTS(resolvedPath)) {
-                // before we can register loaders without requiring users to run node
-                // with --experimental-loader themselves, we have to do a hack here:
-                // bundle the config file w/ ts transforms first, write it to disk,
-                // load it with native Node ESM, then delete the file.
-                fs$l.writeFileSync(resolvedPath + '.mjs', bundled.code);
-                try {
-                    userConfig = (await dynamicImport(`${fileUrl}.mjs?t=${Date.now()}`))
-                        .default;
-                }
-                finally {
-                    fs$l.unlinkSync(resolvedPath + '.mjs');
-                }
-                debug(`TS + native esm config loaded in ${getTime()}`, fileUrl);
-            }
-            else {
-                // using Function to avoid this from being compiled away by TS/Rollup
-                // append a query so that we force reload fresh config in case of
-                // server restart
-                userConfig = (await dynamicImport(`${fileUrl}?t=${Date.now()}`)).default;
-                debug(`native esm config loaded in ${getTime()}`, fileUrl);
-            }
-        }
-        if (!userConfig) {
-            // Bundle config file and transpile it to cjs using esbuild.
-            const bundled = await bundleConfigFile(resolvedPath);
-            dependencies = bundled.dependencies;
-            userConfig = await loadConfigFromBundledFile(resolvedPath, bundled.code);
-            debug(`bundled config file loaded in ${getTime()}`);
-        }
+        const bundled = await bundleConfigFile(resolvedPath, isESM);
+        const userConfig = await loadConfigFromBundledFile(resolvedPath, bundled.code, isESM);
+        debug(`bundled config file loaded in ${getTime()}`);
         const config = await (typeof userConfig === 'function'
             ? userConfig(configEnv)
             : userConfig);
@@ -62670,7 +62770,7 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         return {
             path: normalizePath$3(resolvedPath),
             config,
-            dependencies
+            dependencies: bundled.dependencies
         };
     }
     catch (e) {
@@ -62678,7 +62778,9 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         throw e;
     }
 }
-async function bundleConfigFile(fileName, isESM = false) {
+async function bundleConfigFile(fileName, isESM) {
+    const dirnameVarName = '__vite_injected_original_dirname';
+    const filenameVarName = '__vite_injected_original_filename';
     const importMetaUrlVarName = '__vite_injected_original_import_meta_url';
     const result = await build$3({
         absWorkingDir: process.cwd(),
@@ -62691,19 +62793,48 @@ async function bundleConfigFile(fileName, isESM = false) {
         sourcemap: 'inline',
         metafile: true,
         define: {
+            __dirname: dirnameVarName,
+            __filename: filenameVarName,
             'import.meta.url': importMetaUrlVarName
         },
         plugins: [
             {
                 name: 'externalize-deps',
                 setup(build) {
-                    build.onResolve({ filter: /.*/ }, (args) => {
-                        const id = args.path;
+                    build.onResolve({ filter: /.*/ }, ({ path: id, importer }) => {
+                        // externalize bare imports
                         if (id[0] !== '.' && !path$n.isAbsolute(id)) {
                             return {
                                 external: true
                             };
                         }
+                        // bundle the rest and make sure that the we can also access
+                        // it's third-party dependencies. externalize if not.
+                        // monorepo/
+                        // ├─ package.json
+                        // ├─ utils.js -----------> bundle (share same node_modules)
+                        // ├─ vite-project/
+                        // │  ├─ vite.config.js --> entry
+                        // │  ├─ package.json
+                        // ├─ foo-project/
+                        // │  ├─ utils.js --------> external (has own node_modules)
+                        // │  ├─ package.json
+                        const idFsPath = path$n.resolve(path$n.dirname(importer), id);
+                        const idPkgPath = lookupFile(idFsPath, [`package.json`], {
+                            pathOnly: true
+                        });
+                        if (idPkgPath) {
+                            const idPkgDir = path$n.dirname(idPkgPath);
+                            // if this file needs to go up one or more directory to reach the vite config,
+                            // that means it has it's own node_modules (e.g. foo-project)
+                            if (path$n.relative(idPkgDir, fileName).startsWith('..')) {
+                                return {
+                                    // normalize actual import after bundled as a single vite config
+                                    path: idFsPath,
+                                    external: true
+                                };
+                            }
+                        }
                     });
                 }
             },
@@ -62712,11 +62843,11 @@ async function bundleConfigFile(fileName, isESM = false) {
                 setup(build) {
                     build.onLoad({ filter: /\.[cm]?[jt]s$/ }, async (args) => {
                         const contents = await fs$l.promises.readFile(args.path, 'utf8');
-                        const injectValues = `const __dirname = ${JSON.stringify(path$n.dirname(args.path))};` +
-                            `const __filename = ${JSON.stringify(args.path)};` +
+                        const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path$n.dirname(args.path))};` +
+                            `const ${filenameVarName} = ${JSON.stringify(args.path)};` +
                             `const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(args.path).href)};`;
                         return {
-                            loader: isTS(args.path) ? 'ts' : 'js',
+                            loader: args.path.endsWith('ts') ? 'ts' : 'js',
                             contents: injectValues + contents
                         };
                     });
@@ -62731,22 +62862,42 @@ async function bundleConfigFile(fileName, isESM = false) {
     };
 }
 const _require = createRequire$1(import.meta.url);
-async function loadConfigFromBundledFile(fileName, bundledCode) {
-    const realFileName = fs$l.realpathSync(fileName);
-    const defaultLoader = _require.extensions['.js'];
-    _require.extensions['.js'] = (module, filename) => {
-        if (filename === realFileName) {
-            module._compile(bundledCode, filename);
+async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
+    // for esm, before we can register loaders without requiring users to run node
+    // 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 fileBase = `${fileName}.timestamp-${Date.now()}`;
+        const fileNameTmp = `${fileBase}.mjs`;
+        const fileUrl = `${pathToFileURL(fileBase)}.mjs`;
+        fs$l.writeFileSync(fileNameTmp, bundledCode);
+        try {
+            return (await dynamicImport(fileUrl)).default;
         }
-        else {
-            defaultLoader(module, filename);
+        finally {
+            fs$l.unlinkSync(fileNameTmp);
         }
-    };
-    // clear cache in case of server restart
-    delete _require.cache[_require.resolve(fileName)];
-    const raw = _require(fileName);
-    _require.extensions['.js'] = defaultLoader;
-    return raw.__esModule ? raw.default : raw;
+    }
+    // for cjs, we can register a custom loader via `_require.extensions`
+    else {
+        const extension = path$n.extname(fileName);
+        const realFileName = fs$l.realpathSync(fileName);
+        const loaderExt = extension in _require.extensions ? extension : '.js';
+        const defaultLoader = _require.extensions[loaderExt];
+        _require.extensions[loaderExt] = (module, filename) => {
+            if (filename === realFileName) {
+                module._compile(bundledCode, filename);
+            }
+            else {
+                defaultLoader(module, filename);
+            }
+        };
+        // clear cache in case of server restart
+        delete _require.cache[_require.resolve(fileName)];
+        const raw = _require(fileName);
+        _require.extensions[loaderExt] = defaultLoader;
+        return raw.__esModule ? raw.default : raw;
+    }
 }
 function getDepOptimizationConfig(config, ssr) {
     return ssr ? config.ssr.optimizeDeps : config.optimizeDeps;