vite 3.0.2 → 3.0.5

package/dist/node/chunks/{dep-1513d487.js → dep-5cb728cb.js}

@@ -33,7 +33,7 @@ import { STATUS_CODES } from 'node:http';
 import { createServer as createServer$2 } from 'node:https';
 import require$$1$1 from 'worker_threads';
 import * as qs from 'querystring';
-import readline from 'readline';
+import readline from 'node:readline';
 import { execSync } from 'node:child_process';
 import zlib$1, { gzip } from 'node:zlib';
 
@@ -7255,7 +7255,7 @@ function isReference(node, parent) {
     return false;
 }
 
-var version$1 = "22.0.1";
+var version$1 = "22.0.2";
 var peerDependencies = {
 	rollup: "^2.68.0"
 };
@@ -8213,7 +8213,7 @@ function hasDefineEsmProperty(node) {
   });
 }
 
-function wrapCode(magicString, uses, moduleName, exportsName) {
+function wrapCode(magicString, uses, moduleName, exportsName, indentExclusionRanges) {
   const args = [];
   const passedArgs = [];
   if (uses.module) {
@@ -8226,7 +8226,7 @@ function wrapCode(magicString, uses, moduleName, exportsName) {
   }
   magicString
     .trim()
-    .indent('\t')
+    .indent('\t', { exclude: indentExclusionRanges })
     .prepend(`(function (${args.join(', ')}) {\n`)
     .append(`\n} (${passedArgs.join(', ')}));`);
 }
@@ -8724,6 +8724,7 @@ async function transformCommonjs(
   const replacedGlobal = [];
   const replacedDynamicRequires = [];
   const importedVariables = new Set();
+  const indentExclusionRanges = [];
 
   walk$3(ast, {
     enter(node, parent) {
@@ -9022,6 +9023,11 @@ async function transformCommonjs(
           if (!scope.parent) {
             topLevelDeclarations.push(node);
           }
+          return;
+        case 'TemplateElement':
+          if (node.value.raw.includes('\n')) {
+            indentExclusionRanges.push([node.start, node.end]);
+          }
       }
     },
 
@@ -9154,11 +9160,13 @@ async function transformCommonjs(
       );
 
   if (shouldWrap) {
-    wrapCode(magicString, uses, moduleName, exportsName);
+    wrapCode(magicString, uses, moduleName, exportsName, indentExclusionRanges);
   }
 
   if (usesRequireWrapper) {
-    magicString.trim().indent('\t');
+    magicString.trim().indent('\t', {
+      exclude: indentExclusionRanges
+    });
     magicString.prepend(
       `var ${isRequiredName};
 
@@ -11754,7 +11762,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 +12326,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 +13255,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 +13343,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 +13577,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 +27492,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 +27529,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 +27606,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 +27939,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 +29035,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 +29446,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 +30263,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 +32692,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 +33311,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 +33324,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 +33338,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 +33413,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]');
@@ -33821,10 +33830,6 @@ function resolvePlugin(resolveOptions) {
             if (id.startsWith(browserExternalId)) {
                 return id;
             }
-            // fast path for commonjs proxy modules
-            if (/\?commonjs/.test(id) || id === 'commonjsHelpers.js') {
-                return;
-            }
             const targetWeb = !ssr || ssrTarget === 'webworker';
             // this is passed by @rollup/plugin-commonjs
             const isRequire = resolveOpts?.custom?.['node-resolve']?.isRequire ?? false;
@@ -34095,7 +34100,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,14 +34184,20 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         if (!externalize) {
             return resolved;
         }
+        // don't external symlink packages
+        if (!allowLinkedExternal && !resolved.id.includes('node_modules')) {
+            return resolved;
+        }
         const resolvedExt = path$n.extname(resolved.id);
+        // don't external non-js imports
+        if (resolvedExt &&
+            resolvedExt !== '.js' &&
+            resolvedExt !== '.mjs' &&
+            resolvedExt !== '.cjs') {
+            return resolved;
+        }
         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;
-            }
             if (!pkg?.data.exports && path$n.extname(id) !== resolvedExt) {
                 resolvedId += resolvedExt;
             }
@@ -34537,6 +34548,8 @@ const externalTypes = [
     'stylus',
     'pcss',
     'postcss',
+    // wasm
+    'wasm',
     // known SFC types
     'vue',
     'svelte',
@@ -35383,10 +35396,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 +35463,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 +35474,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 = {};
@@ -35651,7 +35671,7 @@ async function transformGlobImport(code, id, root, resolveId, restoreQueryExtens
             }
         });
         files.forEach((i) => matchedFiles.add(i));
-        const replacement = `Object.assign({${objectProps.join(',')}})`;
+        const replacement = `/* #__PURE__ */ Object.assign({${objectProps.join(',')}})`;
         s.overwrite(start, end, replacement);
         return staticImports;
     }))).flat();
@@ -35985,14 +36005,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 +36049,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({
@@ -36271,11 +36295,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 +36408,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 +36505,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
@@ -37233,7 +37257,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;
@@ -37359,79 +37383,97 @@ function matchAll(regex, string, addition) {
   return matches;
 }
 
-const ESM_STATIC_IMPORT_RE = /(?<=\s|^|;)import\s*(["'\s]*(?<imports>[\w*${}\n\r\t, /]+)from\s*)?["']\s*(?<specifier>(?<="\s*)[^"]*[^"\s](?=\s*")|(?<='\s*)[^']*[^'\s](?=\s*'))\s*["'][\s;]*/gm;
-function findStaticImports(code) {
-  return matchAll(ESM_STATIC_IMPORT_RE, code, { type: "static" });
-}
-function parseStaticImport(matched) {
-  const cleanedImports = (matched.imports || "").replace(/(\/\/[^\n]*\n|\/\*.*\*\/)/g, "").replace(/\s+/g, " ");
-  const namedImports = {};
-  for (const namedImport of cleanedImports.match(/\{([^}]*)\}/)?.[1]?.split(",") || []) {
-    const [, source = namedImport.trim(), importName = source] = namedImport.match(/^\s*([^\s]*) as ([^\s]*)\s*$/) || [];
-    if (source) {
-      namedImports[source] = importName;
-    }
-  }
-  const topLevelImports = cleanedImports.replace(/\{([^}]*)\}/, "");
-  const namespacedImport = topLevelImports.match(/\* as \s*([^\s]*)/)?.[1];
-  const defaultImport = topLevelImports.split(",").find((i) => !i.match(/[*{}]/))?.trim() || void 0;
-  return {
-    ...matched,
-    defaultImport,
-    namespacedImport,
-    namedImports
-  };
-}
-
 const isWindows$3 = process.platform === "win32";
 const own$1 = {}.hasOwnProperty;
 const messages = /* @__PURE__ */ new Map();
 const nodeInternalPrefix = "__node_internal_";
 let userStackTraceLimit;
-createError("ERR_INVALID_MODULE_SPECIFIER", (request, reason, base = void 0) => {
-  return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
-}, TypeError);
-createError("ERR_INVALID_PACKAGE_CONFIG", (path, base, message) => {
-  return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
-}, Error);
-createError("ERR_INVALID_PACKAGE_TARGET", (pkgPath, key, target, isImport = false, base = void 0) => {
-  const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
-  if (key === ".") {
-    assert$1(isImport === false);
-    return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
-  }
-  return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
-}, Error);
-createError("ERR_MODULE_NOT_FOUND", (path, base, type = "package") => {
-  return `Cannot find ${type} '${path}' imported from ${base}`;
-}, Error);
-createError("ERR_PACKAGE_IMPORT_NOT_DEFINED", (specifier, packagePath, base) => {
-  return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
-}, TypeError);
-createError("ERR_PACKAGE_PATH_NOT_EXPORTED", (pkgPath, subpath, base = void 0) => {
-  if (subpath === ".") {
-    return `No "exports" main defined in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
-  }
-  return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
-}, Error);
-createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error);
-createError("ERR_UNKNOWN_FILE_EXTENSION", 'Unknown file extension "%s" for %s', TypeError);
-createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => {
-  let inspected = inspect(value);
-  if (inspected.length > 128) {
-    inspected = `${inspected.slice(0, 128)}...`;
-  }
-  const type = name.includes(".") ? "property" : "argument";
-  return `The ${type} '${name}' ${reason}. Received ${inspected}`;
-}, TypeError);
-createError("ERR_UNSUPPORTED_ESM_URL_SCHEME", (url) => {
-  let message = "Only file and data URLs are supported by the default ESM loader";
-  if (isWindows$3 && url.protocol.length === 2) {
-    message += ". On Windows, absolute paths must be valid file:// URLs";
-  }
-  message += `. Received protocol '${url.protocol}'`;
-  return message;
-}, Error);
+createError(
+  "ERR_INVALID_MODULE_SPECIFIER",
+  (request, reason, base = void 0) => {
+    return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_INVALID_PACKAGE_CONFIG",
+  (path, base, message) => {
+    return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  },
+  Error
+);
+createError(
+  "ERR_INVALID_PACKAGE_TARGET",
+  (pkgPath, key, target, isImport = false, base = void 0) => {
+    const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+    if (key === ".") {
+      assert$1(isImport === false);
+      return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
+    }
+    return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
+      target
+    )} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`;
+  },
+  Error
+);
+createError(
+  "ERR_MODULE_NOT_FOUND",
+  (path, base, type = "package") => {
+    return `Cannot find ${type} '${path}' imported from ${base}`;
+  },
+  Error
+);
+createError(
+  "ERR_PACKAGE_IMPORT_NOT_DEFINED",
+  (specifier, packagePath, base) => {
+    return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_PACKAGE_PATH_NOT_EXPORTED",
+  (pkgPath, subpath, base = void 0) => {
+    if (subpath === ".") {
+      return `No "exports" main defined in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
+    }
+    return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`;
+  },
+  Error
+);
+createError(
+  "ERR_UNSUPPORTED_DIR_IMPORT",
+  "Directory import '%s' is not supported resolving ES modules imported from %s",
+  Error
+);
+createError(
+  "ERR_UNKNOWN_FILE_EXTENSION",
+  'Unknown file extension "%s" for %s',
+  TypeError
+);
+createError(
+  "ERR_INVALID_ARG_VALUE",
+  (name, value, reason = "is invalid") => {
+    let inspected = inspect(value);
+    if (inspected.length > 128) {
+      inspected = `${inspected.slice(0, 128)}...`;
+    }
+    const type = name.includes(".") ? "property" : "argument";
+    return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+  },
+  TypeError
+);
+createError(
+  "ERR_UNSUPPORTED_ESM_URL_SCHEME",
+  (url) => {
+    let message = "Only file and data URLs are supported by the default ESM loader";
+    if (isWindows$3 && url.protocol.length === 2) {
+      message += ". On Windows, absolute paths must be valid file:// URLs";
+    }
+    message += `. Received protocol '${url.protocol}'`;
+    return message;
+  },
+  Error
+);
 function createError(sym, value, def) {
   messages.set(sym, value);
   return makeNodeErrorWithCode(def, sym);
@@ -37467,20 +37509,22 @@ function makeNodeErrorWithCode(Base, key) {
     return error;
   }
 }
-const addCodeToName = hideStackFrames(function(error, name, code) {
-  error = captureLargerStackTrace(error);
-  error.name = `${name} [${code}]`;
-  if (name === "SystemError") {
-    Object.defineProperty(error, "name", {
-      value: name,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    });
-  } else {
-    delete error.name;
+const addCodeToName = hideStackFrames(
+  function(error, name, code) {
+    error = captureLargerStackTrace(error);
+    error.name = `${name} [${code}]`;
+    if (name === "SystemError") {
+      Object.defineProperty(error, "name", {
+        value: name,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    } else {
+      delete error.name;
+    }
   }
-});
+);
 function isErrorStackTraceLimitWritable() {
   const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
   if (desc === void 0) {
@@ -37493,26 +37537,34 @@ function hideStackFrames(fn) {
   Object.defineProperty(fn, "name", { value: hidden });
   return fn;
 }
-const captureLargerStackTrace = hideStackFrames(function(error) {
-  const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
-  if (stackTraceLimitIsWritable) {
-    userStackTraceLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = Number.POSITIVE_INFINITY;
-  }
-  Error.captureStackTrace(error);
-  if (stackTraceLimitIsWritable) {
-    Error.stackTraceLimit = userStackTraceLimit;
+const captureLargerStackTrace = hideStackFrames(
+  function(error) {
+    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+    if (stackTraceLimitIsWritable) {
+      userStackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+    }
+    Error.captureStackTrace(error);
+    if (stackTraceLimitIsWritable) {
+      Error.stackTraceLimit = userStackTraceLimit;
+    }
+    return error;
   }
-  return error;
-});
+);
 function getMessage(key, args, self) {
   const message = messages.get(key);
   if (typeof message === "function") {
-    assert$1(message.length <= args.length, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${message.length}).`);
+    assert$1(
+      message.length <= args.length,
+      `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${message.length}).`
+    );
     return Reflect.apply(message, self, args);
   }
   const expectedLength = (message.match(/%[dfijoOs]/g) || []).length;
-  assert$1(expectedLength === args.length, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`);
+  assert$1(
+    expectedLength === args.length,
+    `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`
+  );
   if (args.length === 0) {
     return message;
   }
@@ -37522,6 +37574,30 @@ function getMessage(key, args, self) {
 Object.freeze(["node", "import"]);
 pathToFileURL$1(process.cwd());
 
+const ESM_STATIC_IMPORT_RE = /(?<=\s|^|;)import\s*(["'\s]*(?<imports>[\w*${}\n\r\t, /]+)from\s*)?["']\s*(?<specifier>(?<="\s*)[^"]*[^"\s](?=\s*")|(?<='\s*)[^']*[^'\s](?=\s*'))\s*["'][\s;]*/gm;
+function findStaticImports(code) {
+  return matchAll(ESM_STATIC_IMPORT_RE, code, { type: "static" });
+}
+function parseStaticImport(matched) {
+  const cleanedImports = (matched.imports || "").replace(/(\/\/[^\n]*\n|\/\*.*\*\/)/g, "").replace(/\s+/g, " ");
+  const namedImports = {};
+  for (const namedImport of cleanedImports.match(/\{([^}]*)\}/)?.[1]?.split(",") || []) {
+    const [, source = namedImport.trim(), importName = source] = namedImport.match(/^\s*([^\s]*) as ([^\s]*)\s*$/) || [];
+    if (source) {
+      namedImports[source] = importName;
+    }
+  }
+  const topLevelImports = cleanedImports.replace(/\{([^}]*)\}/, "");
+  const namespacedImport = topLevelImports.match(/\* as \s*([^\s]*)/)?.[1];
+  const defaultImport = topLevelImports.split(",").find((i) => !i.match(/[*{}]/))?.trim() || void 0;
+  return {
+    ...matched,
+    defaultImport,
+    namespacedImport,
+    namedImports
+  };
+}
+
 const debugHmr = createDebugger('vite:hmr');
 const normalizedClientDir = normalizePath$3(CLIENT_DIR);
 function getShortName(file, root) {
@@ -37976,22 +38052,56 @@ 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) {
+            debug$9(`Failed to node resolve "${id}". Skipping externalizing it by default.`);
+            // 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;
@@ -38000,34 +38110,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;
@@ -38849,7 +38944,7 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
     function defineImport(node, source) {
         deps.add(source);
         const importId = `__vite_ssr_import_${uid++}__`;
-        s.appendLeft(node.start, `const ${importId} = await ${ssrImportKey}(${JSON.stringify(source)});\n`);
+        s.appendRight(node.start, `const ${importId} = await ${ssrImportKey}(${JSON.stringify(source)});\n`);
         return importId;
     }
     function defineExport(position, name, local = name) {
@@ -38862,6 +38957,7 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
         // import { baz } from 'foo' --> baz -> __import_foo__.baz
         // import * as ok from 'foo' --> ok -> __import_foo__
         if (node.type === 'ImportDeclaration') {
+            s.remove(node.start, node.end);
             const importId = defineImport(node, node.source.value);
             for (const spec of node.specifiers) {
                 if (spec.type === 'ImportSpecifier') {
@@ -38875,7 +38971,6 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
                     idToImportMap.set(spec.local.name, importId);
                 }
             }
-            s.remove(node.start, node.end);
         }
     }
     // 2. check all export statements and define exports
@@ -38939,14 +39034,12 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
         }
         // export * from './foo'
         if (node.type === 'ExportAllDeclaration') {
+            s.remove(node.start, node.end);
+            const importId = defineImport(node, node.source.value);
             if (node.exported) {
-                const importId = defineImport(node, node.source.value);
-                s.remove(node.start, node.end);
                 defineExport(node.end, node.exported.name, `${importId}`);
             }
             else {
-                const importId = defineImport(node, node.source.value);
-                s.remove(node.start, node.end);
                 s.appendLeft(node.end, `${ssrExportAllKey}(${importId});`);
             }
         }
@@ -39584,7 +39677,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;
@@ -40818,7 +40911,7 @@ function buildImportAnalysisPlugin(config) {
                 // dynamic import to constant json may get inlined.
                 if (chunk.type === 'chunk' && chunk.code.indexOf(preloadMarker) > -1) {
                     const code = chunk.code;
-                    let imports;
+                    let imports = [];
                     try {
                         imports = parse$b(code)[0].filter((i) => i.d > -1);
                     }
@@ -40945,8 +41038,7 @@ function modulePreloadPolyfillPlugin(config) {
                     return '';
                 }
                 if (!polyfillString) {
-                    polyfillString =
-                        `const p = ${polyfill.toString()};` + `${isModernFlag}&&p();`;
+                    polyfillString = `${isModernFlag}&&(${polyfill.toString()}());`;
                 }
                 return polyfillString;
             }
@@ -40997,7 +41089,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;
@@ -41063,7 +41155,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await import('./dep-3f457808.js').then(function (n) { return n.c; });
+    const { parse, transform } = await import('./dep-b58adab6.js').then(function (n) { return n.c; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -41225,7 +41317,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({
@@ -41409,14 +41504,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
@@ -41481,11 +41578,14 @@ 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];
                 }
-                const shortEmitName = path$n.relative(config.root, id);
+                const shortEmitName = normalizePath$3(path$n.relative(config.root, id));
                 this.emitFile({
                     type: 'asset',
                     fileName: shortEmitName,
@@ -41963,7 +42063,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) {
@@ -42174,7 +42274,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
     const postcssOptions = (postcssConfig && postcssConfig.options) || {};
     const postcssPlugins = postcssConfig && postcssConfig.plugins ? postcssConfig.plugins.slice() : [];
     if (needInlineImport) {
-        postcssPlugins.unshift((await import('./dep-41eb528c.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-94c1417a.js').then(function (n) { return n.i; })).default({
             async resolve(id, basedir) {
                 const publicFile = checkPublicFile(id, config);
                 if (publicFile) {
@@ -42193,7 +42293,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-f07a4e2f.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-0f192b10.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -42504,17 +42604,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) {
@@ -43123,7 +43229,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;
                         }
                     }
@@ -43368,10 +43474,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 {
@@ -43656,7 +43763,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) {
@@ -43683,6 +43790,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 === './';
@@ -49727,30 +49839,44 @@ var guess = function guessEditor (specifiedEditor) {
   try {
     if (process.platform === 'darwin') {
       const output = childProcess$2
-        .execSync('ps x', {
+        .execSync('ps x -o comm=', {
           stdio: ['pipe', 'pipe', 'ignore']
         })
         .toString();
       const processNames = Object.keys(COMMON_EDITORS_OSX);
+      const processList = output.split('\n');
       for (let i = 0; i < processNames.length; i++) {
         const processName = processNames[i];
+        // Find editor by exact match.
         if (output.indexOf(processName) !== -1) {
           return [COMMON_EDITORS_OSX[processName]]
         }
+        const processNameWithoutApplications = processName.replace('/Applications', '');
+        // Find editor installation not in /Applications.
+        if (output.indexOf(processNameWithoutApplications) !== -1) {
+          // Use the CLI command if one is specified
+          if (processName !== COMMON_EDITORS_OSX[processName]) {
+            return [COMMON_EDITORS_OSX[processName]]
+          }
+          // Use a partial match to find the running process path.  If one is found, use the
+          // existing path since it can be running from anywhere.
+          const runningProcess = processList.find((procName) => procName.endsWith(processNameWithoutApplications));
+          if (runningProcess !== undefined) {
+            return [runningProcess]
+          }
+        }
       }
     } else if (process.platform === 'win32') {
       const output = childProcess$2
-        .execSync('powershell -Command "Get-Process | Select-Object Path"', {
-          stdio: ['pipe', 'pipe', 'ignore']
-        })
+        .execSync(
+          'powershell -NoProfile -Command "Get-CimInstance -Query \\"select executablepath from win32_process where executablepath is not null\\" | % { $_.ExecutablePath }"',
+          {
+            stdio: ['pipe', 'pipe', 'ignore']
+          }
+        )
         .toString();
       const runningProcesses = output.split('\r\n');
       for (let i = 0; i < runningProcesses.length; i++) {
-        // `Get-Process` sometimes returns empty lines
-        if (!runningProcesses[i]) {
-          continue
-        }
-
         const fullProcessPath = runningProcesses[i].trim();
         const shortProcessName = path$8.basename(fullProcessPath);
 
@@ -49826,6 +49952,7 @@ var getArgs = function getArgumentsForPosition (
     case 'code':
     case 'code-insiders':
     case 'Code':
+    case 'codium':
       return ['-r', '-g', `${fileName}:${lineNumber}:${columnNumber}`]
     case 'appcode':
     case 'clion':
@@ -49840,7 +49967,7 @@ var getArgs = function getArgumentsForPosition (
     case 'rubymine64':
     case 'webstorm':
     case 'webstorm64':
-      return ['--line', lineNumber, fileName]
+      return ['--line', lineNumber, '--column', columnNumber, fileName]
   }
 
   // For all others, drop the lineNumber until we have
@@ -50019,16 +50146,16 @@ var launchEditorMiddleware = (specifiedEditor, srcRoot, onErrorCallback) => {
 
 async function resolveHttpServer({ proxy }, app, httpsOptions) {
     if (!httpsOptions) {
-        const { createServer } = await import('http');
+        const { createServer } = await import('node:http');
         return createServer(app);
     }
     // #484 fallback to http1 when proxy is needed.
     if (proxy) {
-        const { createServer } = await import('https');
+        const { createServer } = await import('node:https');
         return createServer(httpsOptions, app);
     }
     else {
-        const { createSecureServer } = await import('http2');
+        const { createSecureServer } = await import('node:http2');
         return createSecureServer({
             // Manually increase the session memory to prevent 502 ENHANCE_YOUR_CALM
             // errors on large numbers of requests
@@ -50126,7 +50253,7 @@ function ssrRequireHookPlugin(config) {
 /** Respect the `resolve.dedupe` option in production SSR. */
 function dedupeRequire(dedupe) {
     // eslint-disable-next-line no-restricted-globals
-    const Module = require('module');
+    const Module = require('node:module');
     const resolveFilename = Module._resolveFilename;
     Module._resolveFilename = function (request, parent, isMain, options) {
         if (request[0] !== '.' && request[0] !== '/') {
@@ -50326,7 +50453,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) {
@@ -50407,7 +50534,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;
@@ -57406,9 +57533,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;
             }
@@ -59831,14 +59958,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;
@@ -59994,7 +60113,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}+"`;
@@ -61794,11 +61913,28 @@ function expressionToGlob(node) {
   }
 }
 
+const defaultProtocol = 'file:';
+const ignoredProtocols = ['data:', 'http:', 'https:'];
+
+function shouldIgnore(glob) {
+  const containsAsterisk = glob.includes('*');
+
+  const globURL = new URL(glob, defaultProtocol);
+
+  const containsIgnoredProtocol = ignoredProtocols.some(
+    (ignoredProtocol) => ignoredProtocol === globURL.protocol
+  );
+
+  return !containsAsterisk || containsIgnoredProtocol;
+}
+
 function dynamicImportToGlob(node, sourceString) {
   let glob = expressionToGlob(node);
-  if (!glob.includes('*') || glob.startsWith('data:')) {
+
+  if (shouldIgnore(glob)) {
     return null;
   }
+
   glob = glob.replace(/\*\*/g, '*');
 
   if (glob.startsWith('*')) {
@@ -61942,7 +62078,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) {
@@ -62356,6 +62498,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) {
@@ -62372,12 +62531,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) {
@@ -62496,8 +62649,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,
@@ -62545,6 +62719,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`));
     }
@@ -62557,25 +62748,14 @@ 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,
-            plugins: resolved.plugins.map((p) => p.name)
+            plugins: resolved.plugins.map((p) => p.name),
+            worker: {
+                ...resolved.worker,
+                plugins: resolved.worker.plugins.map((p) => p.name)
+            }
         });
     }
     if (config.build?.terserOptions && config.build.minify !== 'terser') {
@@ -62717,6 +62897,7 @@ async function bundleConfigFile(fileName, isESM) {
         entryPoints: [fileName],
         outfile: 'out.js',
         write: false,
+        target: ['node14.18', 'node16'],
         platform: 'node',
         bundle: true,
         format: isESM ? 'esm' : 'cjs',
@@ -62760,7 +62941,7 @@ async function bundleConfigFile(fileName, isESM) {
                             if (path$n.relative(idPkgDir, fileName).startsWith('..')) {
                                 return {
                                     // normalize actual import after bundled as a single vite config
-                                    path: idFsPath,
+                                    path: pathToFileURL(idFsPath).href,
                                     external: true
                                 };
                             }
@@ -62797,13 +62978,20 @@ 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');
+            try {
+                fs$l.unlinkSync(fileNameTmp);
+            }
+            catch {
+                // already removed if this function is called twice simultaneously
+            }
         }
     }
     // for cjs, we can register a custom loader via `_require.extensions`