vite 3.0.3 → 3.0.6

package/dist/node/chunks/{dep-c6273c7a.js → dep-88cc3a4f.js}

@@ -7,7 +7,7 @@ import require$$0$3 from 'tty';
 import { transform as transform$2, build as build$3, formatMessages } from 'esbuild';
 import require$$0$4, { sep, resolve as resolve$4, posix as posix$1, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join as join$1, win32 as win32$1, isAbsolute as isAbsolute$1, normalize } from 'path';
 import * as require$$0$2 from 'fs';
-import require$$0__default, { statSync as statSync$1, existsSync, readFileSync, promises as promises$1, readdirSync } from 'fs';
+import require$$0__default, { existsSync, readFileSync, statSync as statSync$1, promises as promises$1, readdirSync } from 'fs';
 import require$$0$5 from 'events';
 import assert$1 from 'assert';
 import require$$0$6, { format as format$2, inspect } from 'util';
@@ -22,7 +22,7 @@ import { createHash as createHash$2 } from 'node:crypto';
 import { promisify as promisify$4 } from 'node:util';
 import { promises } from 'node:dns';
 import resolve$5 from 'resolve';
-import { CLIENT_ENTRY, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, OPTIMIZABLE_ENTRY_RE, VALID_ID_PREFIX, FS_PREFIX, wildcardHosts, loopbackHosts, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_MAIN_FIELDS, DEP_VERSION_RE, SPECIAL_QUERY_RE, KNOWN_ASSET_TYPES, JS_TYPES_RE, ESBUILD_MODULES_TARGET, CLIENT_DIR, NULL_BYTE_PLACEHOLDER, VERSION, VITE_PACKAGE_DIR, ENV_ENTRY, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
+import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS$1, wildcardHosts, loopbackHosts, VALID_ID_PREFIX, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_MAIN_FIELDS, DEP_VERSION_RE, SPECIAL_QUERY_RE, KNOWN_ASSET_TYPES, JS_TYPES_RE, ESBUILD_MODULES_TARGET, CLIENT_DIR, NULL_BYTE_PLACEHOLDER, VERSION, VITE_PACKAGE_DIR, ENV_ENTRY, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
 import require$$5 from 'crypto';
 import require$$0$a from 'buffer';
 import require$$0$8, { createRequire as createRequire$2 } from 'module';
@@ -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};
 
@@ -27484,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
@@ -27521,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
@@ -27597,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); };
@@ -27927,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) {
@@ -29023,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" &&
@@ -29433,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;
@@ -30249,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()`.
@@ -32687,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,
@@ -33303,7 +33308,7 @@ function assetPlugin(config) {
             const url = await fileToUrl(id, config, this);
             return `export default ${JSON.stringify(url)}`;
         },
-        renderChunk(code, chunk) {
+        renderChunk(code, chunk, outputOptions) {
             let match;
             let s;
             // Urls added with JS using e.g.
@@ -33319,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);
+                const replacement = toOutputFilePathInString(filename, 'asset', chunk.fileName, 'js', config, outputOptions.format);
                 const replacementString = typeof replacement === 'string'
                     ? JSON.stringify(replacement).slice(1, -1)
                     : `"+${replacement.runtime}+"`;
@@ -33333,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);
+                const replacement = toOutputFilePathInString(publicUrl, 'public', chunk.fileName, 'js', config, outputOptions.format);
                 const replacementString = typeof replacement === 'string'
                     ? JSON.stringify(replacement).slice(1, -1)
                     : `"+${replacement.runtime}+"`;
@@ -33408,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]');
@@ -33822,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;
@@ -34180,18 +34184,20 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr, ex
         if (!externalize) {
             return resolved;
         }
-        // dont external symlink packages
+        // 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 resolved;
-            }
             if (!pkg?.data.exports && path$n.extname(id) !== resolvedExt) {
                 resolvedId += resolvedExt;
             }
@@ -34358,6 +34364,9 @@ function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache
                             // likely UMD or CJS(!!! e.g. firebase 7.x), prefer module
                             entryPoint = data.module;
                         }
+                        else {
+                            entryPoint = browserEntry;
+                        }
                     }
                 }
                 else {
@@ -35390,10 +35399,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);
             }
@@ -35472,24 +35477,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 = {};
@@ -35662,7 +35674,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();
@@ -35815,7 +35827,8 @@ function globEntries(pattern, config) {
                 ? []
                 : [`**/__tests__/**`, `**/coverage/**`])
         ],
-        absolute: true
+        absolute: true,
+        suppressErrors: true // suppress EACCES errors
     });
 }
 const scriptModuleRE = /(<script\b[^>]*type\s*=\s*(?:"module"|'module')[^>]*>)(.*?)<\/script>/gims;
@@ -37374,79 +37387,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);
@@ -37482,20 +37513,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) {
@@ -37508,26 +37541,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;
   }
@@ -37537,6 +37578,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) {
@@ -37675,6 +37740,7 @@ function propagateUpdate(node, boundaries, currentChain = [node]) {
     // if the imports of `node` have not been analyzed, then `node` has not
     // been loaded in the browser and we should stop propagation.
     if (node.id && node.isSelfAccepting === undefined) {
+        debugHmr(`[propagate update] stop propagation because not analyzed: ${picocolors.exports.dim(node.id)}`);
         return false;
     }
     if (node.isSelfAccepting) {
@@ -38006,13 +38072,20 @@ function createIsConfiguredAsSsrExternal(config) {
         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;
+        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
@@ -38876,7 +38949,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) {
@@ -38889,6 +38962,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') {
@@ -38902,7 +38976,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
@@ -38966,14 +39039,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});`);
             }
         }
@@ -38990,7 +39061,7 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
                 // let binding used in a property shorthand
                 // { foo } -> { foo: __import_x__.foo }
                 // skip for destructuring patterns
-                if (!isNodeInPatternWeakMap.get(parent) ||
+                if (!isNodeInPattern(parent) ||
                     isInDestructuringAssignment(parent, parentStack)) {
                     s.appendLeft(id.end, `: ${binding}`);
                 }
@@ -39045,7 +39116,9 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
         dynamicDeps: [...dynamicDeps]
     };
 }
-const isNodeInPatternWeakMap = new WeakMap();
+const isNodeInPatternWeakSet = new WeakSet();
+const setIsNodeInPattern = (node) => isNodeInPatternWeakSet.add(node);
+const isNodeInPattern = (node) => isNodeInPatternWeakSet.has(node);
 /**
  * Same logic from \@vue/compiler-core & \@vue/compiler-sfc
  * Except this is using acorn AST
@@ -39160,7 +39233,7 @@ function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
             }
             else if (node.type === 'Property' && parent.type === 'ObjectPattern') {
                 // mark property in destructuring pattern
-                isNodeInPatternWeakMap.set(node, true);
+                setIsNodeInPattern(node);
             }
             else if (node.type === 'VariableDeclarator') {
                 const parentFunction = findParentFunction(parentStack);
@@ -39203,8 +39276,11 @@ function isRefIdentifier(id, parent, parentStack) {
         return false;
     }
     // property key
-    // this also covers object destructuring pattern
-    if (isStaticPropertyKey(id, parent) || isNodeInPatternWeakMap.get(parent)) {
+    if (isStaticPropertyKey(id, parent)) {
+        return false;
+    }
+    // object destructuring pattern
+    if (isNodeInPattern(parent) && parent.value === id) {
         return false;
     }
     // non-assignment array destructuring pattern
@@ -39990,7 +40066,7 @@ function throwOutdatedRequest(id) {
 const isDebug$1 = !!process.env.DEBUG;
 const debug$7 = createDebugger('vite:import-analysis');
 const clientDir = normalizePath$3(CLIENT_DIR);
-const skipRE = /\.(map|json)$/;
+const skipRE = /\.(map|json)($|\?)/;
 const canSkipImportAnalysis = (id) => skipRE.test(id) || isDirectCSSRequest(id);
 const optimizedDepChunkRE$1 = /\/chunk-[A-Z0-9]{8}\.js/;
 const optimizedDepDynamicRE$1 = /-[A-Z0-9]{8}\.js/;
@@ -40845,7 +40921,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);
                     }
@@ -40972,8 +41048,7 @@ function modulePreloadPolyfillPlugin(config) {
                     return '';
                 }
                 if (!polyfillString) {
-                    polyfillString =
-                        `const p = ${polyfill.toString()};` + `${isModernFlag}&&p();`;
+                    polyfillString = `${isModernFlag}&&(${polyfill.toString()}());`;
                 }
                 return polyfillString;
             }
@@ -41090,7 +41165,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await import('./dep-7f3e64a3.js').then(function (n) { return n.c; });
+    const { parse, transform } = await import('./dep-c7c58113.js').then(function (n) { return n.c; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -41252,7 +41327,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({
@@ -41436,14 +41514,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
@@ -41508,11 +41588,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,
@@ -41766,7 +41849,7 @@ function cssPlugin(config) {
                 }
                 return url;
             };
-            const { code: css, modules, deps, map } = await compileCSS(id, raw, config, urlReplacer, atImportResolvers, server);
+            const { code: css, modules, deps, map } = await compileCSS(id, raw, config, urlReplacer, atImportResolvers);
             if (modules) {
                 moduleCache.set(id, modules);
             }
@@ -41990,7 +42073,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) {
@@ -42201,7 +42284,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) {
@@ -42220,7 +42303,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         logger: config.logger
     }));
     if (isModule) {
-        postcssPlugins.unshift((await import('./dep-676c6c22.js').then(function (n) { return n.i; })).default({
+        postcssPlugins.unshift((await import('./dep-2274fed5.js').then(function (n) { return n.i; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -43156,7 +43239,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;
                         }
                     }
@@ -43401,10 +43484,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 {
@@ -43689,7 +43773,32 @@ function wrapSsrTransform(fn) {
 function injectSsrFlag(options) {
     return { ...(options ?? {}), ssr: true };
 }
-function toOutputFilePathInString(filename, type, hostId, hostType, config, toRelative = toImportMetaURLBasedRelativePath) {
+/*
+  The following functions are copied from rollup
+  https://github.com/rollup/rollup/blob/c5269747cd3dd14c4b306e8cea36f248d9c1aa01/src/ast/nodes/MetaProperty.ts#L189-L232
+
+  https://github.com/rollup/rollup
+  The MIT License (MIT)
+  Copyright (c) 2017 [these people](https://github.com/rollup/rollup/graphs/contributors)
+  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+const getResolveUrl = (path, URL = 'URL') => `new ${URL}(${path}).href`;
+const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(`'${relativePath}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ''}document.currentScript && document.currentScript.src || document.baseURI`);
+const relativeUrlMechanisms = {
+    amd: (relativePath) => {
+        if (relativePath[0] !== '.')
+            relativePath = './' + relativePath;
+        return getResolveUrl(`require.toUrl('${relativePath}'), document.baseURI`);
+    },
+    cjs: (relativePath) => `(typeof document === 'undefined' ? ${getResolveUrl(`'file:' + __dirname + '/${relativePath}'`, `(require('u' + 'rl').URL)`)} : ${getRelativeUrlFromDocument(relativePath)})`,
+    es: (relativePath) => getResolveUrl(`'${relativePath}', import.meta.url`),
+    iife: (relativePath) => getRelativeUrlFromDocument(relativePath),
+    system: (relativePath) => getResolveUrl(`'${relativePath}', module.meta.url`),
+    umd: (relativePath) => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getResolveUrl(`'file:' + __dirname + '/${relativePath}'`, `(require('u' + 'rl').URL)`)} : ${getRelativeUrlFromDocument(relativePath, true)})`
+};
+function toOutputFilePathInString(filename, type, hostId, hostType, config, format, toRelative = getToImportMetaURLBasedRelativePath(format)) {
     const { renderBuiltUrl } = config.experimental;
     let relative = config.base === '' || config.base === './';
     if (renderBuiltUrl) {
@@ -43716,10 +43825,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 getToImportMetaURLBasedRelativePath(format) {
+    const toRelativePath = relativeUrlMechanisms[format];
+    return (filename, importer) => ({
+        runtime: toRelativePath(path$n.posix.relative(path$n.dirname(importer), filename))
+    });
 }
 function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config, toRelative) {
     const { renderBuiltUrl } = config.experimental;
@@ -49765,30 +49875,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);
 
@@ -49864,6 +49988,7 @@ var getArgs = function getArgumentsForPosition (
     case 'code':
     case 'code-insiders':
     case 'Code':
+    case 'codium':
       return ['-r', '-g', `${fileName}:${lineNumber}:${columnNumber}`]
     case 'appcode':
     case 'clion':
@@ -49878,7 +50003,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
@@ -50057,16 +50182,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
@@ -50128,6 +50253,14 @@ async function httpServerStart(httpServer, serverOptions) {
         });
     });
 }
+function setClientErrorHandler(server, logger) {
+    server.on('clientError', (err, socket) => {
+        if (err.code === 'HPE_HEADER_OVERFLOW') {
+            logger.warn(picocolors.exports.yellow('Server responded with status code 431. ' +
+                'See https://vitejs.dev/guide/troubleshooting.html#_431-request-header-fields-too-large.'));
+        }
+    });
+}
 
 /**
  * This plugin hooks into Node's module resolution algorithm at runtime,
@@ -50164,7 +50297,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] !== '/') {
@@ -59006,6 +59139,9 @@ async function createServer(inlineConfig = {}) {
         ? null
         : await resolveHttpServer(serverConfig, middlewares, httpsOptions);
     const ws = createWebSocketServer(httpServer, config, httpsOptions);
+    if (httpServer) {
+        setClientErrorHandler(httpServer, config.logger);
+    }
     const { ignored = [], ...watchOptions } = serverConfig.watch || {};
     const watcher = chokidar.watch(path$n.resolve(root), {
         ignored: [
@@ -59564,6 +59700,7 @@ async function preview(inlineConfig = {}) {
     const config = await resolveConfig(inlineConfig, 'serve', 'production');
     const app = connect();
     const httpServer = await resolveHttpServer(config.preview, app, await resolveHttpsConfig(config.preview?.https));
+    setClientErrorHandler(httpServer, config.logger);
     // apply server hooks from plugins
     const postHooks = [];
     for (const plugin of config.plugins) {
@@ -60007,7 +60144,7 @@ function webWorkerPlugin(config) {
                 map: { mappings: '' } // Empty sourcemap to suppress Rollup warning
             };
         },
-        renderChunk(code, chunk) {
+        renderChunk(code, chunk, outputOptions) {
             let s;
             const result = () => {
                 return (s && {
@@ -60024,7 +60161,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);
+                    const replacement = toOutputFilePathInString(filename, 'asset', chunk.fileName, 'js', config, outputOptions.format);
                     const replacementString = typeof replacement === 'string'
                         ? JSON.stringify(replacement).slice(1, -1)
                         : `"+${replacement.runtime}+"`;
@@ -60032,20 +60169,19 @@ function webWorkerPlugin(config) {
                         contentOnly: true
                     });
                 }
-                // TODO: check if this should be removed
-                if (config.isWorker) {
-                    s = s.replace('import.meta.url', 'self.location.href');
-                    return result();
-                }
-            }
-            if (!isWorker) {
-                const workerMap = workerCache.get(config);
-                workerMap.assets.forEach((asset) => {
-                    this.emitFile(asset);
-                    workerMap.assets.delete(asset.fileName);
-                });
             }
             return result();
+        },
+        generateBundle(opts) {
+            // @ts-ignore asset emits are skipped in legacy bundle
+            if (opts.__vite_skip_asset_emit__ || isWorker) {
+                return;
+            }
+            const workerMap = workerCache.get(config);
+            workerMap.assets.forEach((asset) => {
+                this.emitFile(asset);
+                workerMap.assets.delete(asset.fileName);
+            });
         }
     };
 }
@@ -61824,11 +61960,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('*')) {
@@ -62645,7 +62798,11 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development')
     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') {
@@ -62787,6 +62944,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',
@@ -62830,7 +62988,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
                                 };
                             }
@@ -62875,7 +63033,12 @@ async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
             return (await dynamicImport(fileUrl)).default;
         }
         finally {
-            fs$l.unlinkSync(fileNameTmp);
+            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`