Changeset 0c6b92a for imaps-frontend/node_modules/vite/dist/node/chunks/dep-CB_7IfJ-.js

Timestamp:

12/12/24 17:06:06 (5 weeks ago)

Author:

stefan toskovski <stefantoska84@…>

Branches:

main

Parents:

d565449

Message:

Pred finalna verzija

File:

• imaps-frontend/node_modules/vite/dist/node/chunks/dep-CB_7IfJ-.js (moved) (moved from imaps-frontend/node_modules/vite/dist/node/chunks/dep-mCdpKltl.js ) (179 diffs)

imaps-frontend/node_modules/vite/dist/node/chunks/dep-CB_7IfJ-.js

@@ -10792 +10792 @@
     charToInt[c] = i;
 }
+function decodeInteger(reader, relative) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = reader.next();
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+function hasMoreVlq(reader, max) {
+    if (reader.pos >= max)
+        return false;
+    return reader.peek() !== comma;
+}
+
+const bufLength = 1024 * 16;
 // Provide a fallback for older environments.
 const td = typeof TextDecoder !== 'undefined'
@@ -10811 +10847 @@
             },
         };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
+class StringReader {
+    constructor(buffer) {
+        this.pos = 0;
+        this.buffer = buffer;
+    }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
+    }
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        const { buffer, pos } = this;
+        const idx = buffer.indexOf(char, pos);
+        return idx === -1 ? buffer.length : idx;
+    }
+}
+
 function decode(mappings) {
-    const state = new Int32Array(5);
+    const { length } = mappings;
+    const reader = new StringReader(mappings);
     const decoded = [];
-    let index = 0;
+    let genColumn = 0;
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
     do {
-        const semi = indexOf(mappings, index);
+        const semi = reader.indexOf(';');
         const line = [];
         let sorted = true;
         let lastCol = 0;
-        state[0] = 0;
-        for (let i = index; i < semi; i++) {
+        genColumn = 0;
+        while (reader.pos < semi) {
             let seg;
-            i = decodeInteger(mappings, i, state, 0); // genColumn
-            const col = state[0];
-            if (col < lastCol)
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
                 sorted = false;
-            lastCol = col;
-            if (hasMoreVlq(mappings, i, semi)) {
-                i = decodeInteger(mappings, i, state, 1); // sourcesIndex
-                i = decodeInteger(mappings, i, state, 2); // sourceLine
-                i = decodeInteger(mappings, i, state, 3); // sourceColumn
-                if (hasMoreVlq(mappings, i, semi)) {
-                    i = decodeInteger(mappings, i, state, 4); // namesIndex
-                    seg = [col, state[1], state[2], state[3], state[4]];
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+                sourcesIndex = decodeInteger(reader, sourcesIndex);
+                sourceLine = decodeInteger(reader, sourceLine);
+                sourceColumn = decodeInteger(reader, sourceColumn);
+                if (hasMoreVlq(reader, semi)) {
+                    namesIndex = decodeInteger(reader, namesIndex);
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
                 }
                 else {
-                    seg = [col, state[1], state[2], state[3]];
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
                 }
             }
             else {
-                seg = [col];
+                seg = [genColumn];
             }
             line.push(seg);
+            reader.pos++;
         }
         if (!sorted)
             sort(line);
         decoded.push(line);
-        index = semi + 1;
-    } while (index <= mappings.length);
+        reader.pos = semi + 1;
+    } while (reader.pos <= length);
     return decoded;
-}
-function indexOf(mappings, index) {
-    const idx = mappings.indexOf(';', index);
-    return idx === -1 ? mappings.length : idx;
-}
-function decodeInteger(mappings, pos, state, j) {
-    let value = 0;
-    let shift = 0;
-    let integer = 0;
-    do {
-        const c = mappings.charCodeAt(pos++);
-        integer = charToInt[c];
-        value |= (integer & 31) << shift;
-        shift += 5;
-    } while (integer & 32);
-    const shouldNegate = value & 1;
-    value >>>= 1;
-    if (shouldNegate) {
-        value = -0x80000000 | -value;
-    }
-    state[j] += value;
-    return pos;
-}
-function hasMoreVlq(mappings, i, length) {
-    if (i >= length)
-        return false;
-    return mappings.charCodeAt(i) !== comma;
 }
 function sort(line) {
@@ -10886 +10937 @@
 }
 function encode$1(decoded) {
-    const state = new Int32Array(5);
-    const bufLength = 1024 * 16;
-    const subLength = bufLength - 36;
-    const buf = new Uint8Array(bufLength);
-    const sub = buf.subarray(0, subLength);
-    let pos = 0;
-    let out = '';
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
     for (let i = 0; i < decoded.length; i++) {
         const line = decoded[i];
-        if (i > 0) {
-            if (pos === bufLength) {
-                out += td.decode(buf);
-                pos = 0;
-            }
-            buf[pos++] = semicolon;
-        }
+        if (i > 0)
+            writer.write(semicolon);
         if (line.length === 0)
             continue;
-        state[0] = 0;
+        let genColumn = 0;
         for (let j = 0; j < line.length; j++) {
             const segment = line[j];
-            // We can push up to 5 ints, each int can take at most 7 chars, and we
-            // may push a comma.
-            if (pos > subLength) {
-                out += td.decode(sub);
-                buf.copyWithin(0, subLength, pos);
-                pos -= subLength;
-            }
             if (j > 0)
-                buf[pos++] = comma;
-            pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
             if (segment.length === 1)
                 continue;
-            pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
-            pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
-            pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
             if (segment.length === 4)
                 continue;
-            pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
-        }
-    }
-    return out + td.decode(buf.subarray(0, pos));
-}
-function encodeInteger(buf, pos, state, segment, j) {
-    const next = segment[j];
-    let num = next - state[j];
-    state[j] = next;
-    num = num < 0 ? (-num << 1) | 1 : num << 1;
-    do {
-        let clamped = num & 0b011111;
-        num >>>= 5;
-        if (num > 0)
-            clamped |= 0b100000;
-        buf[pos++] = intToChar[clamped];
-    } while (num > 0);
-    return pos;
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
+        }
+    }
+    return writer.flush();
 }
 
@@ -11699 +11722 @@
                 if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
 
-                while (start < 0) start += this.original.length;
-                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
 
                 if (end > this.original.length) throw new Error('end is out of bounds');
@@ -11796 +11821 @@
 
         remove(start, end) {
-                while (start < 0) start += this.original.length;
-                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
 
                 if (start === end) return this;
@@ -11820 +11847 @@
 
         reset(start, end) {
-                while (start < 0) start += this.original.length;
-                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
 
                 if (start === end) return this;
@@ -11883 +11912 @@
 
         slice(start = 0, end = this.original.length) {
-                while (start < 0) start += this.original.length;
-                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
 
                 let result = '';
@@ -16020 +16051 @@
                         }
 
+                        let m;
+
                         // Is webkit? http://stackoverflow.com/a/16459606/376773
                         // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
@@ -16027 +16060 @@
                                 // Is firefox >= v31?
                                 // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-                                (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+                                (typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
                                 // Double check webkit in userAgent just in case we are in a worker
                                 (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
@@ -16630 +16663 @@
         invalidatePackageData(packageCache, path$n.normalize(id));
       }
-    },
-    handleHotUpdate({ file }) {
-      if (file.endsWith("/package.json")) {
-        invalidatePackageData(packageCache, path$n.normalize(file));
-      }
     }
   };
@@ -16686 +16714 @@
 const replaceSlashOrColonRE = /[/:]/g;
 const replaceDotRE = /\./g;
-const replaceNestedIdRE = /(\s*>\s*)/g;
+const replaceNestedIdRE = /\s*>\s*/g;
 const replaceHashRE = /#/g;
 const flattenId = (id) => {
@@ -17026 +17054 @@
     for (const file of skip) {
       if (path$n.dirname(file) !== ".") {
-        const matched = file.match(splitFirstDirRE);
+        const matched = splitFirstDirRE.exec(file);
         if (matched) {
           nested ??= /* @__PURE__ */ new Map();
@@ -17111 +17139 @@
   return realPath;
 }
-const parseNetUseRE = /^(\w+)? +(\w:) +([^ ]+)\s/;
+const parseNetUseRE = /^\w* +(\w:) +([^ ]+)\s/;
 let firstSafeRealPathSyncRun = false;
 function windowsSafeRealPathSync(path2) {
@@ -17138 +17166 @@
     const lines = stdout.split("\n");
     for (const line of lines) {
-      const m = line.match(parseNetUseRE);
-      if (m) windowsNetworkMap.set(m[3], m[2]);
+      const m = parseNetUseRE.exec(line);
+      if (m) windowsNetworkMap.set(m[2], m[1]);
     }
     if (windowsNetworkMap.size === 0) {
@@ -17155 +17183 @@
   }
 }
-const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g;
+const escapedSpaceCharacters = /(?: |\\t|\\n|\\f|\\r)+/g;
 const imageSetUrlRE = /^(?:[\w\-]+\(.*?\)|'.*?'|".*?"|\S*)/;
 function joinSrcset(ret) {
@@ -17402 +17430 @@
         ...backwardCompatibleWorkerPlugins(value)
       ];
+      continue;
+    } else if (key === "server" && rootPath === "server.hmr") {
+      merged[key] = value;
       continue;
     }
@@ -18191 +18222 @@
                 let lastWildcardIndex = pattern.length;
                 let hasWildcard = false;
+                let hasExtension = false;
+                let hasSlash = false;
+                let lastSlashIndex = -1;
                 for (let i = pattern.length - 1; i > -1; i--) {
-                        if (pattern[i] === '*' || pattern[i] === '?') {
-                                lastWildcardIndex = i;
-                                hasWildcard = true;
+                        const c = pattern[i];
+                        if (!hasWildcard) {
+                                if (c === '*' || c === '?') {
+                                        lastWildcardIndex = i;
+                                        hasWildcard = true;
+                                }
+                        }
+                        if (!hasSlash) {
+                                if (c === '.') {
+                                        hasExtension = true;
+                                } else if (c === '/') {
+                                        lastSlashIndex = i;
+                                        hasSlash = true;
+                                }
+                        }
+                        if (hasWildcard && hasSlash) {
                                 break;
                         }
+                }
+                if (!hasExtension && (!hasWildcard || lastWildcardIndex < lastSlashIndex)) {
+                        // add implicit glob
+                        pattern += `${pattern.endsWith('/') ? '' : '/'}${GLOB_ALL_PATTERN}`;
+                        lastWildcardIndex = pattern.length - 1;
+                        hasWildcard = true;
                 }
 
@@ -18235 +18288 @@
                 }
 
-                // if no wildcard in pattern, filename must be equal to resolved pattern
                 if (!hasWildcard) {
+                        //  no wildcard in pattern, filename must be equal to resolved pattern
                         return filename === resolvedPattern;
+                } else if (
+                        firstWildcardIndex + GLOB_ALL_PATTERN.length ===
+                                resolvedPattern.length - (pattern.length - 1 - lastWildcardIndex) &&
+                        resolvedPattern.slice(firstWildcardIndex, firstWildcardIndex + GLOB_ALL_PATTERN.length) ===
+                                GLOB_ALL_PATTERN
+                ) {
+                        // singular glob-all pattern and we already validated prefix and suffix matches
+                        return true;
                 }
-
                 // complex pattern, use regex to check it
                 if (PATTERN_REGEX_CACHE.has(resolvedPattern)) {
@@ -18296 +18356 @@
         return JSON.parse(
                 JSON.stringify(tsconfig)
-                        // replace ${configDir}, accounting for rebaseRelative emitted ../${configDir}
-                        .replaceAll(/"(?:\.\.\/)*\${configDir}/g, `"${native2posix(configDir)}`)
+                        // replace ${configDir}
+                        .replaceAll(/"\${configDir}/g, `"${native2posix(configDir)}`)
         );
 }
@@ -18891 +18951 @@
  */
 function rebasePath(value, prependPath) {
-        if (path$n.isAbsolute(value)) {
+        if (path$n.isAbsolute(value) || value.startsWith('${configDir}')) {
                 return value;
         } else {
@@ -19094 +19154 @@
 
 const debug$h = createDebugger("vite:esbuild");
-const IIFE_BEGIN_RE = /(const|var)\s+\S+\s*=\s*function\([^()]*\)\s*\{\s*"use strict";/;
+const IIFE_BEGIN_RE = /(?:const|var)\s+\S+\s*=\s*function\([^()]*\)\s*\{\s*"use strict";/;
 const validExtensionRE = /\.\w+$/;
 const jsxExtensionsRE = /\.(?:j|t)sx\b/;
@@ -20276 +20336 @@
         // Force rollup to keep this module from being shared between other entry points if it's an entrypoint.
         // If the resulting chunk is empty, it will be removed in generateBundle.
-        moduleSideEffects: config.command === "build" && this.getModuleInfo(id)?.isEntry ? "no-treeshake" : false
+        moduleSideEffects: config.command === "build" && this.getModuleInfo(id)?.isEntry ? "no-treeshake" : false,
+        meta: config.command === "build" ? { "vite:asset": true } : void 0
       };
     },
@@ -20293 +20354 @@
       for (const file in bundle) {
         const chunk = bundle[file];
-        if (chunk.type === "chunk" && chunk.isEntry && chunk.moduleIds.length === 1 && config.assetsInclude(chunk.moduleIds[0])) {
+        if (chunk.type === "chunk" && chunk.isEntry && chunk.moduleIds.length === 1 && config.assetsInclude(chunk.moduleIds[0]) && this.getModuleInfo(chunk.moduleIds[0])?.meta["vite:asset"]) {
           delete bundle[file];
         }
@@ -20314 +20375 @@
   }
 }
-function fileToDevUrl(id, config) {
+function fileToDevUrl(id, config, skipBase = false) {
   let rtn;
   if (checkPublicFile(id, config)) {
@@ -20323 +20384 @@
     rtn = path$n.posix.join(FS_PREFIX, id);
   }
-  const base = joinUrlSegments(config.server?.origin ?? "", config.base);
+  if (skipBase) {
+    return rtn;
+  }
+  const base = joinUrlSegments(config.server?.origin ?? "", config.decodedBase);
   return joinUrlSegments(base, removeLeadingSlash(rtn));
 }
@@ -20333 +20397 @@
 function publicFileToBuiltUrl(url, config) {
   if (config.command !== "build") {
-    return joinUrlSegments(config.base, url);
+    return joinUrlSegments(config.decodedBase, url);
   }
   const hash = getHash(url);
@@ -20378 +20442 @@
     const { search, hash } = parse$h(id);
     const postfix = (search || "") + (hash || "");
+    const originalFileName = normalizePath$3(path$n.relative(config.root, file));
     const referenceId = pluginContext.emitFile({
+      type: "asset",
       // Ignore directory structure for asset file names
       name: path$n.basename(file),
-      type: "asset",
+      originalFileName,
       source: content
     });
-    const originalName = normalizePath$3(path$n.relative(config.root, file));
-    generatedAssets.get(config).set(referenceId, { originalName });
+    generatedAssets.get(config).set(referenceId, { originalFileName });
     url = `__VITE_ASSET__${referenceId}__${postfix ? `$_${postfix}__` : ``}`;
   }
@@ -20496 +20561 @@
         return manifestChunk;
       }
-      const fileNameToAssetMeta = /* @__PURE__ */ new Map();
       const assets = generatedAssets.get(config);
-      assets.forEach((asset, referenceId) => {
-        try {
-          const fileName = this.getFileName(referenceId);
-          fileNameToAssetMeta.set(fileName, asset);
-        } catch (error) {
-          assets.delete(referenceId);
-        }
-      });
+      const entryCssAssetFileNames = /* @__PURE__ */ new Set();
+      for (const [id, asset] of assets.entries()) {
+        if (asset.isEntry) {
+          try {
+            const fileName = this.getFileName(id);
+            entryCssAssetFileNames.add(fileName);
+          } catch (error) {
+            assets.delete(id);
+          }
+        }
+      }
       const fileNameToAsset = /* @__PURE__ */ new Map();
       for (const file in bundle) {
@@ -20512 +20579 @@
           manifest[getChunkName(chunk)] = createChunk(chunk);
         } else if (chunk.type === "asset" && typeof chunk.name === "string") {
-          const assetMeta = fileNameToAssetMeta.get(chunk.fileName);
-          const src = assetMeta?.originalName ?? chunk.name;
-          const asset = createAsset(chunk, src, assetMeta?.isEntry);
+          const src = chunk.originalFileName ?? chunk.name;
+          const isEntry = entryCssAssetFileNames.has(chunk.fileName);
+          const asset = createAsset(chunk, src, isEntry);
           const file2 = manifest[src]?.file;
           if (file2 && endsWithJSRE.test(file2)) continue;
@@ -20521 +20588 @@
         }
       }
-      assets.forEach(({ originalName }, referenceId) => {
-        if (!manifest[originalName]) {
+      for (const [referenceId, { originalFileName }] of assets.entries()) {
+        if (!manifest[originalFileName]) {
           const fileName = this.getFileName(referenceId);
           const asset = fileNameToAsset.get(fileName);
           if (asset) {
-            manifest[originalName] = asset;
+            manifest[originalFileName] = asset;
           }
         }
-      });
+      }
       outputCount++;
       const output = config.build.rollupOptions?.output;
@@ -20568 +20635 @@
     },
     resolveId(id) {
-      if (!dataUriRE.test(id)) {
+      if (!id.trimStart().startsWith("data:")) {
         return;
       }
@@ -20575 +20642 @@
         return;
       }
-      const match = uri.pathname.match(dataUriRE);
+      const match = dataUriRE.exec(uri.pathname);
       if (!match) {
         return;
@@ -22732 +22799 @@
 const picomatch$2 = picomatch$3;
 const utils$b = utils$k;
-const isEmptyString = val => val === '' || val === './';
+
+const isEmptyString = v => v === '' || v === './';
+const hasBraces = v => {
+  const index = v.indexOf('{');
+  return index > -1 && v.indexOf('}', index) > -1;
+};
 
 /**
@@ -23173 +23245 @@
 micromatch$1.braces = (pattern, options) => {
   if (typeof pattern !== 'string') throw new TypeError('Expected a string');
-  if ((options && options.nobrace === true) || !/\{.*\}/.test(pattern)) {
+  if ((options && options.nobrace === true) || !hasBraces(pattern)) {
     return [pattern];
   }
@@ -23192 +23264 @@
  */
 
+// exposed for tests
+micromatch$1.hasBraces = hasBraces;
 var micromatch_1 = micromatch$1;
 
@@ -27038 +27112 @@
     }
 }
-Collection.maxFlowStringSingleLineLength = 60;
 
 /**
@@ -27070 +27143 @@
     if (!lineWidth || lineWidth < 0)
         return text;
+    if (lineWidth < minContentWidth)
+        minContentWidth = 0;
     const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
     if (text.length <= endStep)
@@ -29642 +29717 @@
     let commentSep = '';
     let hasNewline = false;
-    let hasNewlineAfterProp = false;
     let reqSpace = false;
     let tab = null;
     let anchor = null;
     let tag = null;
+    let newlineAfterProp = null;
     let comma = null;
     let found = null;
@@ -29700 +29775 @@
                 hasNewline = true;
                 if (anchor || tag)
-                    hasNewlineAfterProp = true;
+                    newlineAfterProp = token;
                 hasSpace = true;
                 break;
@@ -29774 +29849 @@
         comment,
         hasNewline,
-        hasNewlineAfterProp,
         anchor,
         tag,
+        newlineAfterProp,
         end,
         start: start ?? end
@@ -29878 +29953 @@
                 continue;
             }
-            if (keyProps.hasNewlineAfterProp || containsNewline(key)) {
+            if (keyProps.newlineAfterProp || containsNewline(key)) {
                 onError(key ?? start[start.length - 1], 'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
             }
@@ -30232 +30307 @@
     return coll;
 }
-function composeCollection(CN, ctx, token, tagToken, onError) {
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
     const tagName = !tagToken
         ? null
         : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
     const expType = token.type === 'block-map'
         ? 'map'
@@ -30249 +30337 @@
         tagName === '!' ||
         (tagName === YAMLMap.tagName && expType === 'map') ||
-        (tagName === YAMLSeq.tagName && expType === 'seq') ||
-        !expType) {
+        (tagName === YAMLSeq.tagName && expType === 'seq')) {
         return resolveCollection(CN, ctx, token, onError, tagName);
     }
@@ -30818 +30905 @@
         case 'block-seq':
         case 'flow-collection':
-            node = composeCollection(CN, ctx, token, tag, onError);
+            node = composeCollection(CN, ctx, token, props, onError);
             if (anchor)
                 node.anchor = anchor.source.substring(1);
@@ -31890 +31977 @@
                 return this.setNext('line-start');
             const s = this.peek(3);
-            if (s === '---' && isEmpty(this.charAt(3))) {
+            if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {
                 yield* this.pushCount(3);
                 this.indentValue = 0;
                 this.indentNext = 0;
-                return 'doc';
-            }
-            else if (s === '...' && isEmpty(this.charAt(3))) {
-                yield* this.pushCount(3);
-                return 'stream';
+                return s === '---' ? 'doc' : 'stream';
             }
         }
@@ -32416 +32499 @@
                 break loop;
         }
-    }
-    while (prev[++i]?.type === 'space') {
-        /* loop */
     }
     return prev.splice(i, prev.length);
@@ -34926 +35006 @@
 }
 
-const htmlProxyRE$1 = /\?html-proxy=?(?:&inline-css)?(?:&style-attr)?&index=(\d+)\.(js|css)$/;
+const htmlProxyRE$1 = /\?html-proxy=?(?:&inline-css)?(?:&style-attr)?&index=(\d+)\.(?:js|css)$/;
 const isHtmlProxyRE = /\?html-proxy\b/;
 const inlineCSSRE$1 = /__VITE_INLINE_CSS__([a-z\d]{8}_\d+)__/g;
@@ -34953 +35033 @@
     },
     load(id) {
-      const proxyMatch = id.match(htmlProxyRE$1);
+      const proxyMatch = htmlProxyRE$1.exec(id);
       if (proxyMatch) {
         const index = Number(proxyMatch[1]);
@@ -34999 +35079 @@
 }
 function traverseNodes(node, visitor) {
+  if (node.nodeName === "template") {
+    node = node.content;
+  }
   visitor(node);
   if (nodeIsElement(node) || node.nodeName === "#document" || node.nodeName === "#document-fragment") {
@@ -35042 +35125 @@
     sourceCodeLocation.endOffset
   );
-  const valueStart = srcString.match(attrValueStartRE);
+  const valueStart = attrValueStartRE.exec(srcString);
   if (!valueStart) {
     throw new Error(
@@ -35110 +35193 @@
       if (id.endsWith(".html")) {
         id = normalizePath$3(id);
-        const relativeUrlPath = path$n.posix.relative(config.root, id);
+        const relativeUrlPath = normalizePath$3(path$n.relative(config.root, id));
         const publicPath = `/${relativeUrlPath}`;
         const publicBase = getBaseInHTML(relativeUrlPath, config);
@@ -35444 +35527 @@
       };
       for (const [normalizedId, html] of processedHtml) {
-        const relativeUrlPath = path$n.posix.relative(config.root, normalizedId);
+        const relativeUrlPath = normalizePath$3(
+          path$n.relative(config.root, normalizedId)
+        );
         const assetsBase = getBaseInHTML(relativeUrlPath, config);
         const toOutputFilePath = (filename, type) => {
@@ -35560 +35645 @@
         this.emitFile({
           type: "asset",
+          originalFileName: normalizedId,
           fileName: shortEmitName,
           source: result
@@ -35828 +35914 @@
   return html;
 }
-const importRE = /\bimport\s*("[^"]*[^\\]"|'[^']*[^\\]');*/g;
+const importRE = /\bimport\s*(?:"[^"]*[^\\]"|'[^']*[^\\]');*/g;
 const commentRE$1 = /\/\*[\s\S]*?\*\/|\/\/.*$/gm;
 function isEntirelyImport(code) {
@@ -35981 +36067 @@
 const functionCallRE = /^[A-Z_][\w-]*\(/i;
 const transformOnlyRE = /[?&]transform-only\b/;
-const nonEscapedDoubleQuoteRe = /(?<!\\)(")/g;
+const nonEscapedDoubleQuoteRe = /(?<!\\)"/g;
 const cssBundleName = "style.css";
 const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
@@ -36122 +36208 @@
       return path$n.dirname(
         assetFileNames({
+          type: "asset",
           name: cssAssetName,
-          type: "asset",
+          originalFileName: null,
           source: "/* vite internal call, ignore */"
         })
@@ -36241 +36328 @@
         const cssAssetDirname = encodedPublicUrls || relative ? slash$1(getCssAssetDirname(cssAssetName)) : void 0;
         const toRelative = (filename) => {
-          const relativePath = path$n.posix.relative(cssAssetDirname, filename);
+          const relativePath = normalizePath$3(
+            path$n.relative(cssAssetDirname, filename)
+          );
           return relativePath[0] === "." ? relativePath : "./" + relativePath;
         };
@@ -36259 +36348 @@
         });
         if (encodedPublicUrls) {
-          const relativePathToPublicFromCSS = path$n.posix.relative(
-            cssAssetDirname,
-            ""
+          const relativePathToPublicFromCSS = normalizePath$3(
+            path$n.relative(cssAssetDirname, "")
           );
           chunkCSS2 = chunkCSS2.replace(publicAssetUrlRE, (_, hash) => {
@@ -36292 +36380 @@
           const [full, idHex] = match;
           const id = Buffer.from(idHex, "hex").toString();
-          const originalFilename = cleanUrl(id);
+          const originalFileName = cleanUrl(id);
           const cssAssetName = ensureFileExt(
-            path$n.basename(originalFilename),
+            path$n.basename(originalFileName),
             ".css"
           );
@@ -36306 +36394 @@
           urlEmitTasks.push({
             cssAssetName,
-            originalFilename,
+            originalFileName,
             content: cssContent,
             start: match.index,
@@ -36328 +36416 @@
         for (const {
           cssAssetName,
-          originalFilename,
+          originalFileName,
           content,
           start,
@@ -36334 +36422 @@
         } of urlEmitTasks) {
           const referenceId = this.emitFile({
+            type: "asset",
             name: cssAssetName,
-            type: "asset",
+            originalFileName,
             source: content
           });
-          generatedAssets.get(config).set(referenceId, { originalName: originalFilename });
+          generatedAssets.get(config).set(referenceId, { originalFileName });
           const filename = this.getFileName(referenceId);
           chunk.viteMetadata.importedAssets.add(cleanUrl(filename));
@@ -36362 +36451 @@
             const cssFullAssetName = ensureFileExt(chunk.name, ".css");
             const cssAssetName = chunk.isEntry && (!chunk.facadeModuleId || !isCSSRequest(chunk.facadeModuleId)) ? path$n.basename(cssFullAssetName) : cssFullAssetName;
-            const originalFilename = getChunkOriginalFileName(
+            const originalFileName = getChunkOriginalFileName(
               chunk,
               config.root,
@@ -36372 +36461 @@
             });
             const referenceId = this.emitFile({
+              type: "asset",
               name: cssAssetName,
-              type: "asset",
+              originalFileName,
               source: chunkCSS
             });
-            generatedAssets.get(config).set(referenceId, { originalName: originalFilename, isEntry });
+            generatedAssets.get(config).set(referenceId, { originalFileName, isEntry });
             chunk.viteMetadata.importedCss.add(this.getFileName(referenceId));
           } else if (!config.build.ssr) {
@@ -36504 +36594 @@
         });
       }
+      const cssAssets = Object.values(bundle).filter(
+        (asset) => asset.type === "asset" && asset.fileName.endsWith(".css")
+      );
+      for (const cssAsset of cssAssets) {
+        if (typeof cssAsset.source === "string") {
+          cssAsset.source = cssAsset.source.replace(viteHashUpdateMarkerRE, "");
+        }
+      }
     }
   };
@@ -36526 +36624 @@
         if (pluginImports) {
           const depModules = /* @__PURE__ */ new Set();
-          const devBase = config.base;
           for (const file of pluginImports) {
             depModules.add(
               isCSSRequest(file) ? moduleGraph.createFileOnlyEntry(file) : await moduleGraph.ensureEntryFromUrl(
-                stripBase(
-                  await fileToUrl$1(file, config, this),
-                  (config.server?.origin ?? "") + devBase
+                fileToDevUrl(
+                  file,
+                  config,
+                  /* skipBase */
+                  true
                 ),
                 ssr
@@ -36583 +36682 @@
     },
     get sass() {
-      return sassResolve || (sassResolve = config.createResolver({
-        extensions: [".scss", ".sass", ".css"],
-        mainFields: ["sass", "style"],
-        conditions: ["sass", "style"],
-        tryIndex: true,
-        tryPrefix: "_",
-        preferRelative: true
-      }));
+      if (!sassResolve) {
+        const resolver = config.createResolver({
+          extensions: [".scss", ".sass", ".css"],
+          mainFields: ["sass", "style"],
+          conditions: ["sass", "style"],
+          tryIndex: true,
+          tryPrefix: "_",
+          preferRelative: true
+        });
+        sassResolve = async (...args) => {
+          if (args[0].startsWith("file://")) {
+            args[0] = fileURLToPath(args[0]);
+          }
+          return resolver(...args);
+        };
+      }
+      return sassResolve;
     },
     get less() {
@@ -36676 +36784 @@
   const needInlineImport = code.includes("@import");
   const hasUrl = cssUrlRE.test(code) || cssImageSetRE.test(code);
-  const lang = id.match(CSS_LANGS_RE)?.[1];
+  const lang = CSS_LANGS_RE.exec(id)?.[1];
   const postcssConfig = await resolvePostcssConfig(config);
   if (lang === "css" && !postcssConfig && !isModule && !needInlineImport && !hasUrl) {
@@ -36725 +36833 @@
         async load(id2) {
           const code2 = await fs__default.promises.readFile(id2, "utf-8");
-          const lang2 = id2.match(CSS_LANGS_RE)?.[1];
+          const lang2 = CSS_LANGS_RE.exec(id2)?.[1];
           if (isPreProcessor(lang2)) {
             const result = await compileCSSPreprocessors(
@@ -36883 +36991 @@
   };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-VqAwxVIc.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-CjZz522d.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-C6EFp3uH.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-Ba1kN6Mp.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = /* @__PURE__ */ new WeakMap();
@@ -36922 +37030 @@
   ]) : map1;
 }
+const viteHashUpdateMarker = "/*$vite$:1*/";
+const viteHashUpdateMarkerRE = /\/\*\$vite\$:\d+\*\//;
 async function finalizeCss(css, minify, config) {
   if (css.includes("@import") || css.includes("@charset")) {
@@ -36929 +37039 @@
     css = await minifyCSS(css, config, false);
   }
+  css += viteHashUpdateMarker;
   return css;
 }
@@ -37191 +37302 @@
   }
 }
+function loadSassPackage(root) {
+  try {
+    const path2 = loadPreprocessorPath("sass-embedded", root);
+    return { name: "sass-embedded", path: path2 };
+  } catch (e1) {
+    try {
+      const path2 = loadPreprocessorPath("sass" /* sass */, root);
+      return { name: "sass", path: path2 };
+    } catch (e2) {
+      throw e1;
+    }
+  }
+}
 let cachedSss;
 function loadSss(root) {
@@ -37218 +37342 @@
   return data;
 }
-const makeScssWorker = (resolvers, alias, maxWorkers) => {
+const makeScssWorker = (resolvers, alias, maxWorkers, packageName) => {
   const internalImporter = async (url, importer, filename) => {
     importer = cleanScssBugUrl(importer);
@@ -37231 +37355 @@
           resolvers.sass
         );
+        if (packageName === "sass-embedded") {
+          return data;
+        }
         return fixScssBugImportValue(data);
       } catch (data) {
@@ -37288 +37415 @@
   return worker;
 };
+const makeModernScssWorker = (resolvers, alias, maxWorkers) => {
+  const internalCanonicalize = async (url, importer) => {
+    importer = cleanScssBugUrl(importer);
+    const resolved = await resolvers.sass(url, importer);
+    return resolved ?? null;
+  };
+  const internalLoad = async (file, rootFile) => {
+    const result = await rebaseUrls(file, rootFile, alias, "$", resolvers.sass);
+    if (result.contents) {
+      return result.contents;
+    }
+    return await fsp.readFile(result.file, "utf-8");
+  };
+  const worker = new WorkerWithFallback(
+    () => async (sassPath, data, options) => {
+      const sass = require(sassPath);
+      const path2 = require("node:path");
+      const { fileURLToPath: fileURLToPath2, pathToFileURL: pathToFileURL2 } = (
+        // eslint-disable-next-line no-restricted-globals
+        require("node:url")
+      );
+      const sassOptions = { ...options };
+      sassOptions.url = pathToFileURL2(options.filename);
+      sassOptions.sourceMap = options.enableSourcemap;
+      const internalImporter = {
+        async canonicalize(url, context) {
+          const importer = context.containingUrl ? fileURLToPath2(context.containingUrl) : options.filename;
+          const resolved = await internalCanonicalize(url, importer);
+          return resolved ? pathToFileURL2(resolved) : null;
+        },
+        async load(canonicalUrl) {
+          const ext = path2.extname(canonicalUrl.pathname);
+          let syntax = "scss";
+          if (ext === ".sass") {
+            syntax = "indented";
+          } else if (ext === ".css") {
+            syntax = "css";
+          }
+          const contents = await internalLoad(
+            fileURLToPath2(canonicalUrl),
+            options.filename
+          );
+          return { contents, syntax, sourceMapUrl: canonicalUrl };
+        }
+      };
+      sassOptions.importers = [
+        ...sassOptions.importers ?? [],
+        internalImporter
+      ];
+      const result = await sass.compileStringAsync(data, sassOptions);
+      return {
+        css: result.css,
+        map: result.sourceMap ? JSON.stringify(result.sourceMap) : void 0,
+        stats: {
+          includedFiles: result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath2(url))
+        }
+      };
+    },
+    {
+      parentFunctions: {
+        internalCanonicalize,
+        internalLoad
+      },
+      shouldUseFake(_sassPath, _data, options) {
+        return !!(options.functions && Object.keys(options.functions).length > 0 || options.importers && (!Array.isArray(options.importers) || options.importers.length > 0));
+      },
+      max: maxWorkers
+    }
+  );
+  return worker;
+};
+const makeModernCompilerScssWorker = (resolvers, alias, _maxWorkers) => {
+  let compilerPromise;
+  const worker = {
+    async run(sassPath, data, options) {
+      const sass = (await import(pathToFileURL(sassPath).href)).default;
+      compilerPromise ??= sass.initAsyncCompiler();
+      const compiler = await compilerPromise;
+      const sassOptions = { ...options };
+      sassOptions.url = pathToFileURL(options.filename);
+      sassOptions.sourceMap = options.enableSourcemap;
+      const internalImporter = {
+        async canonicalize(url, context) {
+          const importer = context.containingUrl ? fileURLToPath(context.containingUrl) : options.filename;
+          const resolved = await resolvers.sass(url, cleanScssBugUrl(importer));
+          return resolved ? pathToFileURL(resolved) : null;
+        },
+        async load(canonicalUrl) {
+          const ext = path$n.extname(canonicalUrl.pathname);
+          let syntax = "scss";
+          if (ext === ".sass") {
+            syntax = "indented";
+          } else if (ext === ".css") {
+            syntax = "css";
+          }
+          const result2 = await rebaseUrls(
+            fileURLToPath(canonicalUrl),
+            options.filename,
+            alias,
+            "$",
+            resolvers.sass
+          );
+          const contents = result2.contents ?? await fsp.readFile(result2.file, "utf-8");
+          return { contents, syntax, sourceMapUrl: canonicalUrl };
+        }
+      };
+      sassOptions.importers = [
+        ...sassOptions.importers ?? [],
+        internalImporter
+      ];
+      const result = await compiler.compileStringAsync(data, sassOptions);
+      return {
+        css: result.css,
+        map: result.sourceMap ? JSON.stringify(result.sourceMap) : void 0,
+        stats: {
+          includedFiles: result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath(url))
+        }
+      };
+    },
+    async stop() {
+      (await compilerPromise)?.dispose();
+      compilerPromise = void 0;
+    }
+  };
+  return worker;
+};
 const scssProcessor = (maxWorkers) => {
   const workerMap = /* @__PURE__ */ new Map();
@@ -37297 +37550 @@
     },
     async process(source, root, options, resolvers) {
-      const sassPath = loadPreprocessorPath("sass" /* sass */, root);
+      const sassPackage = loadSassPackage(root);
+      const api = options.api ?? "legacy";
       if (!workerMap.has(options.alias)) {
         workerMap.set(
           options.alias,
-          makeScssWorker(resolvers, options.alias, maxWorkers)
+          api === "modern-compiler" ? makeModernCompilerScssWorker(resolvers, options.alias) : api === "modern" ? makeModernScssWorker(resolvers, options.alias, maxWorkers) : makeScssWorker(
+            resolvers,
+            options.alias,
+            maxWorkers,
+            sassPackage.name
+          )
         );
       }
@@ -37317 +37576 @@
       try {
         const result = await worker.run(
-          sassPath,
+          sassPackage.path,
           data,
           optionsWithoutAdditionalData
@@ -37323 +37582 @@
         const deps = result.stats.includedFiles.map((f) => cleanScssBugUrl(f));
         const map2 = result.map ? JSON.parse(result.map.toString()) : void 0;
+        if (map2) {
+          map2.sources = map2.sources.map(
+            (url) => url.startsWith("file://") ? normalizePath$3(fileURLToPath(url)) : url
+          );
+        }
         return {
           code: result.css.toString(),
@@ -37652 +37916 @@
       source,
       root,
-      { ...options, indentedSyntax: true },
+      { ...options, indentedSyntax: true, syntax: "indented" },
       resolvers
     );
@@ -37740 +38004 @@
         deps.add(dep.url);
         if (urlReplacer) {
-          const replaceUrl = await urlReplacer(dep.url, id);
+          const replaceUrl = await urlReplacer(
+            dep.url,
+            toAbsolute(dep.loc.filePath)
+          );
           css = css.replace(dep.placeholder, () => replaceUrl);
         } else {
@@ -37809 +38076 @@
   const targets = {};
   const entriesWithoutES = arraify(esbuildTarget).flatMap((e) => {
-    const match = e.match(esRE);
+    const match = esRE.exec(e);
     if (!match) return e;
     const year = Number(match[1]);
@@ -44839 +45106 @@
   emacs: 'emacs',
   gvim: 'gvim',
+  idea: 'idea',
   'idea.sh': 'idea',
+  phpstorm: 'phpstorm',
   'phpstorm.sh': 'phpstorm',
+  pycharm: 'pycharm',
   'pycharm.sh': 'pycharm',
+  rubymine: 'rubymine',
   'rubymine.sh': 'rubymine',
   sublime_text: 'subl',
   vim: 'vim',
+  webstorm: 'webstorm',
   'webstorm.sh': 'webstorm',
+  goland: 'goland',
   'goland.sh': 'goland',
+  rider: 'rider',
   'rider.sh': 'rider'
 };
@@ -45156 +45430 @@
   }
 
-  // cmd.exe on Windows is vulnerable to RCE attacks given a file name of the
-  // form "C:\Users\myusername\Downloads\& curl 172.21.93.52". Use a safe file
-  // name pattern to validate user-provided file names. This doesn't cover the
-  // entire range of valid file names but should cover almost all of them in practice.
-  // (Backport of
-  // https://github.com/facebook/create-react-app/pull/4866
-  // and
-  // https://github.com/facebook/create-react-app/pull/5431)
-
-  // Allows alphanumeric characters, periods, dashes, slashes, and underscores.
-  const WINDOWS_CMD_SAFE_FILE_NAME_PATTERN = /^([A-Za-z]:[/\\])?[\p{L}0-9/.\-_\\]+$/u;
-  if (
-    process.platform === 'win32' &&
-    !WINDOWS_CMD_SAFE_FILE_NAME_PATTERN.test(fileName.trim())
-  ) {
-    console.log();
-    console.log(
-      colors.red('Could not open ' + path$5.basename(fileName) + ' in the editor.')
-    );
-    console.log();
-    console.log(
-      'When running on Windows, file names are checked against a safe file name ' +
-        'pattern to protect against remote code execution attacks. File names ' +
-        'may consist only of alphanumeric characters (all languages), periods, ' +
-        'dashes, slashes, and underscores.'
-    );
-    console.log();
-    return
-  }
-
   if (lineNumber) {
     const extraArgs = getArgumentsForPosition(editor, fileName, lineNumber, columnNumber);
@@ -45201 +45445 @@
 
   if (process.platform === 'win32') {
-    // On Windows, launch the editor in a shell because spawn can only
-    // launch .exe files.
-    _childProcess = childProcess$1.spawn(
-      'cmd.exe',
-      ['/C', editor].concat(args),
-      { stdio: 'inherit' }
-    );
+    // On Windows, we need to use `exec` with the `shell: true` option,
+    // and some more sanitization is required.
+
+    // However, CMD.exe on Windows is vulnerable to RCE attacks given a file name of the
+    // form "C:\Users\myusername\Downloads\& curl 172.21.93.52".
+    // `create-react-app` used a safe file name pattern to validate user-provided file names:
+    // - https://github.com/facebook/create-react-app/pull/4866
+    // - https://github.com/facebook/create-react-app/pull/5431
+    // But that's not a viable solution for this package because
+    // it's depended on by so many meta frameworks that heavily rely on
+    // special characters in file names for filesystem-based routing.
+    // We need to at least:
+    // - Support `+` because it's used in SvelteKit and Vike
+    // - Support `$` because it's used in Remix
+    // - Support `(` and `)` because they are used in Analog, SolidStart, and Vike
+    // - Support `@` because it's used in Vike
+    // - Support `[` and `]` because they are widely used for [slug]
+    // So here we choose to use `^` to escape special characters instead.
+
+    // According to https://ss64.com/nt/syntax-esc.html,
+    // we can use `^` to escape `&`, `<`, `>`, `|`, `%`, and `^`
+    // I'm not sure if we have to escape all of these, but let's do it anyway
+    function escapeCmdArgs (cmdArgs) {
+      return cmdArgs.replace(/([&|<>,;=^])/g, '^$1')
+    }
+
+    // Need to double quote the editor path in case it contains spaces;
+    // If the fileName contains spaces, we also need to double quote it in the arguments
+    // However, there's a case that it's concatenated with line number and column number
+    // which is separated by `:`. We need to double quote the whole string in this case.
+    // Also, if the string contains the escape character `^`, it needs to be quoted, too.
+    function doubleQuoteIfNeeded(str) {
+      if (str.includes('^')) {
+        // If a string includes an escaped character, not only does it need to be quoted,
+        // but the quotes need to be escaped too.
+        return `^"${str}^"`
+      } else if (str.includes(' ')) {
+        return `"${str}"`
+      } 
+      return str
+    }
+    const launchCommand = [editor, ...args.map(escapeCmdArgs)]
+      .map(doubleQuoteIfNeeded)
+      .join(' ');
+
+    _childProcess = childProcess$1.exec(launchCommand, {
+      stdio: 'inherit',
+      shell: true
+    });
   } else {
     _childProcess = childProcess$1.spawn(editor, args, { stdio: 'inherit' });
@@ -45331 +45617 @@
       logger.warn(
         colors$1.yellow(
-          "Server responded with status code 431. See https://vitejs.dev/guide/troubleshooting.html#_431-request-header-fields-too-large."
+          "Server responded with status code 431. See https://vite.dev/guide/troubleshooting.html#_431-request-header-fields-too-large."
         )
       );
@@ -45355 +45641 @@
   let fsUtils = cachedFsUtilsMap.get(config);
   if (!fsUtils) {
-    if (config.command !== "serve" || config.server.fs.cachedChecks === false || config.server.watch?.ignored || process.versions.pnp) {
+    if (config.command !== "serve" || config.server.fs.cachedChecks !== true || config.server.watch?.ignored || process.versions.pnp) {
       fsUtils = commonFsUtils;
     } else if (!config.resolve.preserveSymlinks && config.root !== getRealPath(config.root)) {
@@ -45946 +46232 @@
             } else if (isProduction) {
               this.warn(
-                `Module "${id}" has been externalized for browser compatibility, imported by "${importer}". See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`
+                `Module "${id}" has been externalized for browser compatibility, imported by "${importer}". See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`
               );
             }
@@ -45963 +46249 @@
           return `export default new Proxy({}, {
   get(_, key) {
-    throw new Error(\`Module "${id}" has been externalized for browser compatibility. Cannot access "${id}.\${key}" in client code.  See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
+    throw new Error(\`Module "${id}" has been externalized for browser compatibility. Cannot access "${id}.\${key}" in client code.  See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
   }
 })`;
@@ -46126 +46412 @@
 function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = false, externalize, allowLinkedExternal = true) {
   const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
-  const deepMatch = id.match(deepImportRE);
+  const deepMatch = deepImportRE.exec(id);
   const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : cleanUrl(id);
   let basedir;
@@ -46702 +46988 @@
       key !== 'splice'
     ) {
-      console.warn(\`Module "${path2}" has been externalized for browser compatibility. Cannot access "${path2}.\${key}" in client code. See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
+      console.warn(\`Module "${path2}" has been externalized for browser compatibility. Cannot access "${path2}.\${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
     }
   }
@@ -46929 +47215 @@
         const metadata = depsOptimizer.metadata;
         const file = cleanUrl(id);
-        const versionMatch = id.match(DEP_VERSION_RE);
+        const versionMatch = DEP_VERSION_RE.exec(file);
         const browserHash = versionMatch ? versionMatch[1].split("=")[1] : void 0;
         const info = optimizedDepInfoFromFile(metadata, file);
@@ -46987 +47273 @@
 const nonJsRe = /\.json(?:$|\?)/;
 const isNonJsRequest = (request) => nonJsRe.test(request);
+const importMetaEnvMarker = "__vite_import_meta_env__";
+const importMetaEnvKeyReCache = /* @__PURE__ */ new Map();
 function definePlugin(config) {
   const isBuild = config.command === "build";
@@ -47035 +47323 @@
     }
     if ("import.meta.env" in define) {
-      define["import.meta.env"] = serializeDefine({
-        ...importMetaEnvKeys,
-        SSR: ssr + "",
-        ...userDefineEnv
-      });
-    }
+      define["import.meta.env"] = importMetaEnvMarker;
+    }
+    const importMetaEnvVal = serializeDefine({
+      ...importMetaEnvKeys,
+      SSR: ssr + "",
+      ...userDefineEnv
+    });
     const patternKeys = Object.keys(userDefine);
     if (replaceProcessEnv && Object.keys(processEnv).length) {
@@ -47049 +47338 @@
     }
     const pattern = patternKeys.length ? new RegExp(patternKeys.map(escapeRegex).join("|")) : null;
-    return [define, pattern];
+    return [define, pattern, importMetaEnvVal];
   }
   const defaultPattern = generatePattern(false);
@@ -47066 +47355 @@
         return;
       }
-      const [define, pattern] = ssr ? ssrPattern : defaultPattern;
+      let [define, pattern, importMetaEnvVal] = ssr ? ssrPattern : defaultPattern;
       if (!pattern) return;
       pattern.lastIndex = 0;
       if (!pattern.test(code)) return;
-      return await replaceDefine(code, id, define, config);
+      const hasDefineImportMetaEnv = "import.meta.env" in define;
+      let marker = importMetaEnvMarker;
+      if (hasDefineImportMetaEnv && code.includes(marker)) {
+        let i = 1;
+        do {
+          marker = importMetaEnvMarker + i++;
+        } while (code.includes(marker));
+        if (marker !== importMetaEnvMarker) {
+          define = { ...define, "import.meta.env": marker };
+        }
+      }
+      const result = await replaceDefine(code, id, define, config);
+      if (hasDefineImportMetaEnv) {
+        result.code = result.code.replaceAll(
+          getImportMetaEnvKeyRe(marker),
+          (m) => "undefined".padEnd(m.length)
+        );
+        if (result.code.includes(marker)) {
+          result.code = `const ${marker} = ${importMetaEnvVal};
+` + result.code;
+          if (result.map) {
+            const map = JSON.parse(result.map);
+            map.mappings = ";" + map.mappings;
+            result.map = map;
+          }
+        }
+      }
+      return result;
     }
   };
 }
 async function replaceDefine(code, id, define, config) {
-  const replacementMarkers = {};
-  const env = define["import.meta.env"];
-  if (env && !canJsonParse(env)) {
-    const marker = `_${getHash(env, env.length - 2)}_`;
-    replacementMarkers[marker] = env;
-    define = { ...define, "import.meta.env": marker };
-  }
   const esbuildOptions = config.esbuild || {};
   const result = await transform$1(code, {
@@ -47107 +47416 @@
     }
   }
-  for (const marker in replacementMarkers) {
-    result.code = result.code.replaceAll(marker, replacementMarkers[marker]);
-  }
   return {
     code: result.code,
@@ -47133 +47439 @@
   return JSON.stringify(value);
 }
-function canJsonParse(value) {
-  try {
-    JSON.parse(value);
-    return true;
-  } catch {
-    return false;
-  }
+function getImportMetaEnvKeyRe(marker) {
+  let re = importMetaEnvKeyReCache.get(marker);
+  if (!re) {
+    re = new RegExp(`${marker}\\..+?\\b`, "g");
+    importMetaEnvKeyReCache.set(marker, re);
+  }
+  return re;
 }
 
@@ -47283 +47589 @@
       }
       throw new Error(
-        '"ESM integration proposal for Wasm" is not supported currently. Use vite-plugin-wasm or other community plugins to handle this. Alternatively, you can use `.wasm?init` or `.wasm?url`. See https://vitejs.dev/guide/features.html#webassembly for more details.'
+        '"ESM integration proposal for Wasm" is not supported currently. Use vite-plugin-wasm or other community plugins to handle this. Alternatively, you can use `.wasm?init` or `.wasm?url`. See https://vite.dev/guide/features.html#webassembly for more details.'
       );
     }
@@ -47347 +47653 @@
         saveEmitWorkerAsset(config, {
           fileName: outputChunk2.fileName,
+          originalFileName: null,
           source: outputChunk2.code
         });
@@ -47364 +47671 @@
       saveEmitWorkerAsset(config, {
         fileName: mapFileName,
+        originalFileName: null,
         source: data
       });
@@ -47387 +47695 @@
     saveEmitWorkerAsset(config, {
       fileName,
+      originalFileName: null,
       source: outputChunk.code
     });
@@ -47465 +47774 @@
         if (injectEnv) {
           const s = new MagicString(raw);
-          s.prepend(injectEnv);
+          s.prepend(injectEnv + ";\n");
           return {
             code: s.toString(),
@@ -47484 +47793 @@
       let urlCode;
       if (isBuild) {
-        if (isWorker && this.getModuleInfo(cleanUrl(id))?.isEntry) {
+        if (isWorker && config.bundleChain.at(-1) === cleanUrl(id)) {
           urlCode = "self.location.href";
         } else if (inlineRE.test(id)) {
@@ -47611 +47920 @@
           type: "asset",
           fileName: asset.fileName,
+          originalFileName: asset.originalFileName,
           source: asset.source
         });
@@ -47813 +48123 @@
             file ??= url[0] === "/" ? slash$1(path$n.join(config.publicDir, url)) : slash$1(path$n.resolve(path$n.dirname(id), url));
           }
-          if (isBuild && config.isWorker && this.getModuleInfo(cleanUrl(file))?.isEntry) {
+          if (isBuild && config.isWorker && config.bundleChain.at(-1) === cleanUrl(file)) {
             s.update(expStart, expEnd, "self.location.href");
           } else {
@@ -48468 +48778 @@
 }
 function cleanStack(stack) {
-  return stack.split(/\n/g).filter((l) => /^\s*at/.test(l)).join("\n");
+  return stack.split(/\n/).filter((l) => /^\s*at/.test(l)).join("\n");
 }
 function logError(server, err) {
@@ -49306 +49616 @@
 const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
 const langRE = /\blang\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
-const contextRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const svelteScriptModuleRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const svelteModuleRE = /\smodule\b/i;
 function esbuildScanPlugin(config, container, depImports, missing, entries) {
   const seen = /* @__PURE__ */ new Map();
@@ -49392 +49703 @@
         const matches = raw.matchAll(scriptRE);
         for (const [, openTag, content] of matches) {
-          const typeMatch = openTag.match(typeRE);
+          const typeMatch = typeRE.exec(openTag);
           const type = typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3]);
-          const langMatch = openTag.match(langRE);
+          const langMatch = langRE.exec(openTag);
           const lang = langMatch && (langMatch[1] || langMatch[2] || langMatch[3]);
           if (isHtml && type !== "module") {
@@ -49408 +49719 @@
             loader = "ts";
           }
-          const srcMatch = openTag.match(srcRE);
+          const srcMatch = srcRE.exec(openTag);
           if (srcMatch) {
             const src = srcMatch[1] || srcMatch[2] || srcMatch[3];
@@ -49437 +49748 @@
             }
             const virtualModulePath = JSON.stringify(virtualModulePrefix + key);
-            const contextMatch = openTag.match(contextRE);
-            const context = contextMatch && (contextMatch[1] || contextMatch[2] || contextMatch[3]);
-            if (p.endsWith(".svelte") && context !== "module") {
-              js += `import ${virtualModulePath}
+            let addedImport = false;
+            if (p.endsWith(".svelte")) {
+              let isModule = svelteModuleRE.test(openTag);
+              if (!isModule) {
+                const contextMatch = svelteScriptModuleRE.exec(openTag);
+                const context = contextMatch && (contextMatch[1] || contextMatch[2] || contextMatch[3]);
+                isModule = context === "module";
+              }
+              if (!isModule) {
+                addedImport = true;
+                js += `import ${virtualModulePath}
 `;
-            } else {
+              }
+            }
+            if (!addedImport) {
               js += `export * from ${virtualModulePath}
 `;
@@ -49659 +49979 @@
                 filePath = "./" + filePath;
               }
-              const matched2 = slash$1(filePath).match(exportsValueGlobRe);
+              const matched2 = exportsValueGlobRe.exec(slash$1(filePath));
               if (matched2) {
                 let allGlobSame = matched2.length === 2;
@@ -49770 +50090 @@
   const logNewlyDiscoveredDeps = () => {
     if (newDepsToLog.length) {
-      config.logger.info(
+      logger.info(
         colors$1.green(
           `\u2728 new dependencies optimized: ${depsLogString(newDepsToLog)}`
@@ -49784 +50104 @@
   const logDiscoveredDepsWhileScanning = () => {
     if (discoveredDepsWhileScanning.length) {
-      config.logger.info(
+      logger.info(
         colors$1.green(
           `\u2728 discovered while scanning: ${depsLogString(
@@ -49978 +50298 @@
             if (warnAboutMissedDependencies) {
               logDiscoveredDepsWhileScanning();
-              config.logger.info(
+              logger.info(
                 colors$1.magenta(
                   `\u2757 add these dependencies to optimizeDeps.include to speed up cold start`
@@ -50010 +50330 @@
             if (warnAboutMissedDependencies) {
               logDiscoveredDepsWhileScanning();
-              config.logger.info(
+              logger.info(
                 colors$1.magenta(
                   `\u2757 add these dependencies to optimizeDeps.include to avoid a full page reload during cold start`
@@ -50026 +50346 @@
           );
           if (needsInteropMismatch.length > 0) {
-            config.logger.warn(
+            logger.warn(
               `Mixed ESM and CJS detected in ${colors$1.yellow(
                 needsInteropMismatch.join(", ")
@@ -51318 +51638 @@
   };
   return function viteServePublicMiddleware(req, res, next) {
-    if (publicFiles && !publicFiles.has(toFilePath(req.url)) || isImportRequest(req.url) || isInternalRequest(req.url)) {
+    if (publicFiles && !publicFiles.has(toFilePath(req.url)) || isImportRequest(req.url) || isInternalRequest(req.url) || // for `/public-file.js?url` to be transformed
+    urlRE.test(req.url)) {
       return next();
     }
@@ -51414 +51735 @@
 ${server.config.server.fs.allow.map((i) => `- ${i}`).join("\n")}
 
-Refer to docs https://vitejs.dev/config/server-options.html#server-fs-allow for configurations and more details.`;
+Refer to docs https://vite.dev/config/server-options.html#server-fs-allow for configurations and more details.`;
     server.config.logger.error(urlMessage);
     server.config.logger.warnOnce(hintMessage + "\n");
@@ -52073 +52394 @@
   const idToImportMap = /* @__PURE__ */ new Map();
   const declaredConst = /* @__PURE__ */ new Set();
-  const hoistIndex = code.match(hashbangRE)?.[0].length ?? 0;
+  const hoistIndex = hashbangRE.exec(code)?.[0].length ?? 0;
   function defineImport(index, source, metadata) {
     deps.add(source);
@@ -52097 +52418 @@
     );
   }
+  const imports = [];
+  const exports = [];
   for (const node of ast.body) {
     if (node.type === "ImportDeclaration") {
-      const importId = defineImport(hoistIndex, node.source.value, {
-        importedNames: node.specifiers.map((s2) => {
-          if (s2.type === "ImportSpecifier")
-            return s2.imported.type === "Identifier" ? s2.imported.name : (
-              // @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
-              s2.imported.value
-            );
-          else if (s2.type === "ImportDefaultSpecifier") return "default";
-        }).filter(isDefined)
-      });
-      s.remove(node.start, node.end);
-      for (const spec of node.specifiers) {
-        if (spec.type === "ImportSpecifier") {
-          if (spec.imported.type === "Identifier") {
-            idToImportMap.set(
-              spec.local.name,
-              `${importId}.${spec.imported.name}`
-            );
-          } else {
-            idToImportMap.set(
-              spec.local.name,
-              `${importId}[${// @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
-              JSON.stringify(spec.imported.value)}]`
-            );
-          }
-        } else if (spec.type === "ImportDefaultSpecifier") {
-          idToImportMap.set(spec.local.name, `${importId}.default`);
+      imports.push(node);
+    } else if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") {
+      exports.push(node);
+    }
+  }
+  for (const node of imports) {
+    const importId = defineImport(hoistIndex, node.source.value, {
+      importedNames: node.specifiers.map((s2) => {
+        if (s2.type === "ImportSpecifier")
+          return s2.imported.type === "Identifier" ? s2.imported.name : (
+            // @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+            s2.imported.value
+          );
+        else if (s2.type === "ImportDefaultSpecifier") return "default";
+      }).filter(isDefined)
+    });
+    s.remove(node.start, node.end);
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier") {
+        if (spec.imported.type === "Identifier") {
+          idToImportMap.set(
+            spec.local.name,
+            `${importId}.${spec.imported.name}`
+          );
         } else {
-          idToImportMap.set(spec.local.name, importId);
-        }
-      }
-    }
-  }
-  for (const node of ast.body) {
+          idToImportMap.set(
+            spec.local.name,
+            `${importId}[${// @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+            JSON.stringify(spec.imported.value)}]`
+          );
+        }
+      } else if (spec.type === "ImportDefaultSpecifier") {
+        idToImportMap.set(spec.local.name, `${importId}.default`);
+      } else {
+        idToImportMap.set(spec.local.name, importId);
+      }
+    }
+  }
+  for (const node of exports) {
     if (node.type === "ExportNamedDeclaration") {
       if (node.declaration) {
@@ -52248 +52576 @@
   });
   let map = s.generateMap({ hires: "boundary" });
+  map.sources = [path$n.basename(url)];
+  map.sourcesContent = [originalCode];
   if (inMap && inMap.mappings && "sources" in inMap && inMap.sources.length > 0) {
     map = combineSourcemaps(url, [
-      {
-        ...map,
-        sources: inMap.sources,
-        sourcesContent: inMap.sourcesContent
-      },
+      map,
       inMap
     ]);
-  } else {
-    map.sources = [path$n.basename(url)];
-    map.sourcesContent = [originalCode];
   }
   return {
@@ -52526 +52849 @@
 const pendingModuleDependencyGraph = /* @__PURE__ */ new Map();
 const importErrors = /* @__PURE__ */ new WeakMap();
-async function ssrLoadModule(url, server, context = { global }, fixStacktrace) {
+async function ssrLoadModule(url, server, fixStacktrace) {
   url = unwrapId$1(url);
   const pending = pendingModules.get(url);
@@ -52532 +52855 @@
     return pending;
   }
-  const modulePromise = instantiateModule(url, server, context, fixStacktrace);
+  const modulePromise = instantiateModule(url, server, fixStacktrace);
   pendingModules.set(url, modulePromise);
   modulePromise.catch(() => {
@@ -52540 +52863 @@
   return modulePromise;
 }
-async function instantiateModule(url, server, context = { global }, fixStacktrace) {
+async function instantiateModule(url, server, fixStacktrace) {
   const { moduleGraph } = server;
   const mod = await moduleGraph.ensureEntryFromUrl(url, true);
@@ -52604 +52927 @@
         }
       }
-      return ssrLoadModule(dep, server, context, fixStacktrace);
+      return ssrLoadModule(dep, server, fixStacktrace);
     } catch (err) {
       importErrors.set(err, { importee: dep });
@@ -52639 +52962 @@
   try {
     const initModule = new AsyncFunction(
-      `global`,
       ssrModuleExportsKey,
       ssrImportMetaKey,
@@ -52649 +52971 @@
     );
     await initModule(
-      context.global,
       ssrModule,
       ssrImportMeta,
@@ -54036 +54357 @@
     if (!normalizePath$3(outDir).startsWith(withTrailingSlash(root))) {
       logger?.warn(
-        picocolorsExports.yellow(
+        colors$1.yellow(
           `
-${picocolorsExports.bold(`(!)`)} outDir ${picocolorsExports.white(
-            picocolorsExports.dim(outDir)
+${colors$1.bold(`(!)`)} outDir ${colors$1.white(
+            colors$1.dim(outDir)
           )} is not inside project root and will not be emptied.
 Use --emptyOutDir to override.
@@ -54050 +54371 @@
   return true;
 }
-function resolveChokidarOptions(config, options, resolvedOutDirs, emptyOutDir) {
+function resolveChokidarOptions(options, resolvedOutDirs, emptyOutDir, cacheDir) {
   const { ignored: ignoredList, ...otherOptions } = options ?? {};
   const ignored = [
@@ -54057 +54378 @@
     "**/test-results/**",
     // Playwright
-    glob.escapePath(config.cacheDir) + "/**",
+    glob.escapePath(cacheDir) + "/**",
     ...arraify(ignoredList || [])
   ];
@@ -61463 +61784 @@
     if (ifNoneMatch) {
       const moduleByEtag = server.moduleGraph.getModuleByEtag(ifNoneMatch);
-      if (moduleByEtag?.transformResult?.etag === ifNoneMatch) {
+      if (moduleByEtag?.transformResult?.etag === ifNoneMatch && moduleByEtag?.url === req.url) {
         const maybeMixedEtag = isCSSRequest(req.url);
         if (!maybeMixedEtag) {
@@ -61541 +61862 @@
         warnAboutExplicitPublicPathInUrl(url);
       }
+      if ((rawRE.test(url) || urlRE.test(url)) && !ensureServingAccess(url, server, res, next)) {
+        return;
+      }
       if (isJSRequest(url) || isImportRequest(url) || isCSSRequest(url) || isHTMLProxy(url)) {
         url = removeImportQuery(url);
@@ -61713 +62037 @@
       }
       if (preTransformUrl) {
-        preTransformRequest(server, preTransformUrl, config.base);
+        try {
+          preTransformUrl = decodeURI(preTransformUrl);
+        } catch (err) {
+          return url2;
+        }
+        preTransformRequest(server, preTransformUrl, config.decodedBase);
       }
     }
@@ -61724 +62053 @@
   const { config, moduleGraph, watcher } = server;
   const base = config.base || "/";
+  const decodedBase = config.decodedBase || "/";
   let proxyModulePath;
   let proxyModuleUrl;
@@ -61735 +62065 @@
     proxyModuleUrl = wrapId$1(proxyModulePath);
   }
-  proxyModuleUrl = joinUrlSegments(base, proxyModuleUrl);
+  proxyModuleUrl = joinUrlSegments(decodedBase, proxyModuleUrl);
   const s = new MagicString(html);
   let inlineModuleIndex = -1;
@@ -61767 +62097 @@
       `<script type="module" src="${modulePath}"><\/script>`
     );
-    preTransformRequest(server, modulePath, base);
+    preTransformRequest(server, modulePath, decodedBase);
   };
   await traverseHtml(html, filename, (node) => {
@@ -61929 +62259 @@
   };
 }
-function preTransformRequest(server, url, base) {
+function preTransformRequest(server, decodedUrl, decodedBase) {
   if (!server.config.server.preTransformRequests) return;
-  try {
-    url = unwrapId$1(stripBase(decodeURI(url), base));
-  } catch {
-    return;
-  }
-  server.warmupRequest(url);
+  decodedUrl = unwrapId$1(stripBase(decodedUrl, decodedBase));
+  server.warmupRequest(decodedUrl);
 }
 
@@ -62107 +62433 @@
     mod.importers.forEach((importer) => {
       if (!importer.acceptedHmrDeps.has(mod)) {
-        const shouldSoftInvalidateImporter = importer.staticImportedUrls?.has(mod.url) || softInvalidate;
+        const shouldSoftInvalidateImporter = (importer.staticImportedUrls?.has(mod.url) || softInvalidate) && importer.type !== "css";
         this.invalidateModule(
           importer,
@@ -62446 +62772 @@
   );
   const resolvedWatchOptions = resolveChokidarOptions(
-    config,
     {
       disableGlobbing: true,
@@ -62452 +62777 @@
     },
     resolvedOutDirs,
-    emptyOutDir
+    emptyOutDir,
+    config.cacheDir
   );
   const middlewares = connect$1();
@@ -62532 +62858 @@
     },
     async ssrLoadModule(url, opts) {
-      return ssrLoadModule(url, server, void 0, opts?.fixStacktrace);
+      return ssrLoadModule(url, server, opts?.fixStacktrace);
     },
     async ssrFetchModule(url, importer) {
@@ -63026 +63352 @@
       seenIds.add(ignoredId);
       markIdAsDone(ignoredId);
+    } else {
+      checkIfCrawlEndAfterTimeout();
     }
     return onCrawlEndPromiseWithResolvers.promise;
   }
   function markIdAsDone(id) {
-    if (registeredIds.has(id)) {
-      registeredIds.delete(id);
-      checkIfCrawlEndAfterTimeout();
-    }
+    registeredIds.delete(id);
+    checkIfCrawlEndAfterTimeout();
   }
   function checkIfCrawlEndAfterTimeout() {
@@ -63742 +64068 @@
             url = injectQuery(url, "import");
           } else if ((isRelative || isSelfImport) && !DEP_VERSION_RE.test(url)) {
-            const versionMatch = importer.match(DEP_VERSION_RE);
+            const versionMatch = DEP_VERSION_RE.exec(importer);
             if (versionMatch) {
               url = injectQuery(url, versionMatch[1]);
@@ -64183 +64509 @@
   }
   const pathname = url.replace(/[?#].*$/, "");
-  const { search, hash } = new URL(url, "http://vitejs.dev");
+  const { search, hash } = new URL(url, "http://vite.dev");
   return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
 }
@@ -64215 +64541 @@
     );
     const cspNonce = cspNonceMeta?.nonce || cspNonceMeta?.getAttribute("nonce");
-    promise = Promise.all(
+    promise = Promise.allSettled(
       deps.map((dep) => {
         dep = assetsURL(dep, importerUrl);
@@ -64237 +64563 @@
         if (!isCss) {
           link.as = "script";
-          link.crossOrigin = "";
-        }
+        }
+        link.crossOrigin = "";
         link.href = dep;
         if (cspNonce) {
@@ -64256 +64582 @@
     );
   }
-  return promise.then(() => baseModule()).catch((err) => {
-    const e = new Event("vite:preloadError", { cancelable: true });
+  function handlePreloadError(err) {
+    const e = new Event("vite:preloadError", {
+      cancelable: true
+    });
     e.payload = err;
     window.dispatchEvent(e);
@@ -64263 +64591 @@
       throw err;
     }
+  }
+  return promise.then((res) => {
+    for (const item of res || []) {
+      if (item.status !== "rejected") continue;
+      handlePreloadError(item.reason);
+    }
+    return baseModule().catch(handlePreloadError);
   });
 }
@@ -64269 +64604 @@
   const isWorker = config.isWorker;
   const insertPreload = !(ssr || !!config.build.lib || isWorker);
-  const resolveModulePreloadDependencies = config.build.modulePreload && config.build.modulePreload.resolveDependencies;
   const renderBuiltUrl = config.experimental.renderBuiltUrl;
-  const customModulePreloadPaths = !!(resolveModulePreloadDependencies || renderBuiltUrl);
   const isRelativeBase = config.base === "./" || config.base === "";
-  const optimizeModulePreloadRelativePaths = isRelativeBase && !customModulePreloadPaths;
   const { modulePreload } = config.build;
   const scriptRel2 = modulePreload && modulePreload.polyfill ? `'modulepreload'` : `(${detectScriptRel.toString()})()`;
-  const assetsURL2 = customModulePreloadPaths ? (
-    // If `experimental.renderBuiltUrl` or `build.modulePreload.resolveDependencies` are used
-    // the dependencies are already resolved. To avoid the need for `new URL(dep, import.meta.url)`
-    // a helper `__vitePreloadRelativeDep` is used to resolve from relative paths which can be minimized.
-    `function(dep, importerUrl) { return dep[0] === '.' ? new URL(dep, importerUrl).href : dep }`
-  ) : optimizeModulePreloadRelativePaths ? (
-    // If there isn't custom resolvers affecting the deps list, deps in the list are relative
-    // to the current chunk and are resolved to absolute URL by the __vitePreload helper itself.
+  const assetsURL2 = renderBuiltUrl || isRelativeBase ? (
+    // If `experimental.renderBuiltUrl` is used, the dependencies might be relative to the current chunk.
+    // If relative base is used, the dependencies are relative to the current chunk.
     // The importerUrl is passed as third parameter to __vitePreload in this case
     `function(dep, importerUrl) { return new URL(dep, importerUrl).href }`
@@ -64335 +64662 @@
           }
           if (match[3]) {
-            let names2 = match[4].match(/\.([^.?]+)/)?.[1] || "";
+            let names2 = /\.([^.?]+)/.exec(match[4])?.[1] || "";
             if (names2 === "default") {
               names2 = "default: __vite_default__";
@@ -64377 +64704 @@
           str().appendRight(
             expEnd,
-            `,${isModernFlag}?${preloadMarker}:void 0${optimizeModulePreloadRelativePaths || customModulePreloadPaths ? ",import.meta.url" : ""})`
+            `,${isModernFlag}?${preloadMarker}:void 0${renderBuiltUrl || isRelativeBase ? ",import.meta.url" : ""})`
           );
         }
@@ -64558 +64885 @@
               }
               if (markerStartPos2 > 0) {
-                const depsArray = deps.size > 1 || // main chunk is removed
+                let depsArray = deps.size > 1 || // main chunk is removed
                 hasRemovedPureCssChunk && deps.size > 0 ? modulePreload === false ? (
                   // CSS deps use the same mechanism as module preloads, so even if disabled,
@@ -64564 +64891 @@
                   [...deps].filter((d) => d.endsWith(".css"))
                 ) : [...deps] : [];
+                const resolveDependencies = modulePreload ? modulePreload.resolveDependencies : void 0;
+                if (resolveDependencies && normalizedFile) {
+                  const cssDeps = [];
+                  const otherDeps = [];
+                  for (const dep of depsArray) {
+                    (dep.endsWith(".css") ? cssDeps : otherDeps).push(dep);
+                  }
+                  depsArray = [
+                    ...resolveDependencies(normalizedFile, otherDeps, {
+                      hostId: file,
+                      hostType: "js"
+                    }),
+                    ...cssDeps
+                  ];
+                }
                 let renderedDeps;
-                if (normalizedFile && customModulePreloadPaths) {
-                  const { modulePreload: modulePreload2 } = config.build;
-                  const resolveDependencies = modulePreload2 ? modulePreload2.resolveDependencies : void 0;
-                  let resolvedDeps;
-                  if (resolveDependencies) {
-                    const cssDeps = [];
-                    const otherDeps = [];
-                    for (const dep of depsArray) {
-                      (dep.endsWith(".css") ? cssDeps : otherDeps).push(dep);
-                    }
-                    resolvedDeps = [
-                      ...resolveDependencies(normalizedFile, otherDeps, {
-                        hostId: file,
-                        hostType: "js"
-                      }),
-                      ...cssDeps
-                    ];
-                  } else {
-                    resolvedDeps = depsArray;
-                  }
-                  renderedDeps = resolvedDeps.map((dep) => {
+                if (renderBuiltUrl) {
+                  renderedDeps = depsArray.map((dep) => {
                     const replacement = toOutputFilePathInJS(
                       dep,
@@ -64604 +64927 @@
                       // Don't include the assets dir if the default asset file names
                       // are used, the path will be reconstructed by the import preload helper
-                      optimizeModulePreloadRelativePaths ? addFileDep(toRelativePath(d, file)) : addFileDep(d)
+                      isRelativeBase ? addFileDep(toRelativePath(d, file)) : addFileDep(d)
                     )
                   );
@@ -64919 +65242 @@
   );
   const options = config.build;
+  const { root, logger, packageCache } = config;
   const ssr = !!options.ssr;
   const libOptions = options.lib;
-  config.logger.info(
+  logger.info(
     colors$1.cyan(
       `vite v${VERSION} ${colors$1.green(
@@ -64928 +65252 @@
     )
   );
-  const resolve = (p) => path$n.resolve(config.root, p);
+  const resolve = (p) => path$n.resolve(root, p);
   const input = libOptions ? options.rollupOptions?.input || (typeof libOptions.entry === "string" ? resolve(libOptions.entry) : Array.isArray(libOptions.entry) ? libOptions.entry.map(resolve) : Object.fromEntries(
     Object.entries(libOptions.entry).map(([alias, file]) => [
@@ -65001 +65325 @@
     enhanceRollupError(e);
     clearLine();
-    config.logger.error(e.message, { error: e });
+    logger.error(e.message, { error: e });
   };
   let bundle;
@@ -65008 +65332 @@
     const buildOutputOptions = (output = {}) => {
       if (output.output) {
-        config.logger.warn(
+        logger.warn(
           `You've set "rollupOptions.output.output" in your config. This is deprecated and will override all Vite.js default output options. Please use "rollupOptions.output" instead.`
         );
@@ -65018 +65342 @@
       }
       if (output.sourcemap) {
-        config.logger.warnOnce(
+        logger.warnOnce(
           colors$1.yellow(
             `Vite does not support "rollupOptions.output.sourcemap". Please use "build.sourcemap" instead.`
@@ -65029 +65353 @@
       const jsExt = ssrNodeBuild || libOptions ? resolveOutputJsExtension(
         format,
-        findNearestPackageData(config.root, config.packageCache)?.data.type
+        findNearestPackageData(root, packageCache)?.data.type
       ) : "js";
       return {
@@ -65047 +65371 @@
           format,
           name,
-          config.root,
+          root,
           jsExt,
-          config.packageCache
+          packageCache
         ) : path$n.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
         chunkFileNames: libOptions ? `[name]-[hash].${jsExt}` : path$n.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
@@ -65060 +65384 @@
       options.rollupOptions?.output,
       libOptions,
-      config.logger
+      logger
     );
     const normalizedOutputs = [];
@@ -65071 +65395 @@
     }
     const resolvedOutDirs = getResolvedOutDirs(
-      config.root,
+      root,
       options.outDir,
       options.rollupOptions?.output
@@ -65077 +65401 @@
     const emptyOutDir = resolveEmptyOutDir(
       options.emptyOutDir,
-      config.root,
+      root,
       resolvedOutDirs,
-      config.logger
+      logger
     );
     if (config.build.watch) {
-      config.logger.info(colors$1.cyan(`
+      logger.info(colors$1.cyan(`
 watching for file changes...`));
       const resolvedChokidarOptions = resolveChokidarOptions(
-        config,
         config.build.watch.chokidar,
         resolvedOutDirs,
-        emptyOutDir
+        emptyOutDir,
+        config.cacheDir
       );
       const { watch } = await import('rollup');
@@ -65101 +65425 @@
       watcher.on("event", (event) => {
         if (event.code === "BUNDLE_START") {
-          config.logger.info(colors$1.cyan(`
+          logger.info(colors$1.cyan(`
 build started...`));
           if (options.write) {
@@ -65108 +65432 @@
         } else if (event.code === "BUNDLE_END") {
           event.result.close();
-          config.logger.info(colors$1.cyan(`built in ${event.duration}ms.`));
+          logger.info(colors$1.cyan(`built in ${event.duration}ms.`));
         } else if (event.code === "ERROR") {
           outputBuildError(event.error);
@@ -65125 +65449 @@
       res.push(await bundle[options.write ? "write" : "generate"](output));
     }
-    config.logger.info(
+    logger.info(
       `${colors$1.green(`\u2713 built in ${displayTime(Date.now() - startTime)}`)}`
     );
@@ -65133 +65457 @@
     clearLine();
     if (startTime) {
-      config.logger.error(
+      logger.error(
         `${colors$1.red("x")} Build failed in ${displayTime(Date.now() - startTime)}`
       );
@@ -65380 +65704 @@
 const getResolveUrl = (path2, URL = "URL") => `new ${URL}(${path2}).href`;
 const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(
-  `'${escapeId(partialEncodeURIPath(relativePath))}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ""}document.currentScript && document.currentScript.src || document.baseURI`
+  `'${escapeId(partialEncodeURIPath(relativePath))}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ""}document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || document.baseURI`
 );
 const getFileUrlFromFullPath = (path2) => `require('u' + 'rl').pathToFileURL(${path2}).href`;
@@ -65436 +65760 @@
     return toRelative(filename, hostId);
   }
-  return joinUrlSegments(config.base, filename);
+  return joinUrlSegments(config.decodedBase, filename);
 }
 function createToImportMetaURLBasedRelativeRuntime(format, isWorker) {
@@ -65473 +65797 @@
     return toRelative(filename, hostId);
   } else {
-    return joinUrlSegments(config.base, filename);
+    return joinUrlSegments(config.decodedBase, filename);
   }
 }
@@ -66005 +66329 @@
     rollupOptions: config.worker?.rollupOptions || {}
   };
+  const base = withTrailingSlash(resolvedBase);
   resolved = {
     configFile: configFile ? normalizePath$3(configFile) : void 0,
@@ -66012 +66337 @@
     inlineConfig,
     root: resolvedRoot,
-    base: withTrailingSlash(resolvedBase),
+    base,
+    decodedBase: decodeURI(base),
     rawBase: resolvedBase,
     resolve: resolveOptions,
@@ -66163 +66489 @@
   }
   if (!isBuild || !isExternal) {
-    base = new URL(base, "http://vitejs.dev").pathname;
+    base = new URL(base, "http://vite.dev").pathname;
     if (base[0] !== "/") {
       base = "/" + base;
@@ -66201 +66527 @@
     return null;
   }
-  const isESM = isFilePathESM(resolvedPath);
+  const isESM = typeof process.versions.deno === "string" || isFilePathESM(resolvedPath);
   try {
     const bundled = await bundleConfigFile(resolvedPath, isESM);
@@ -66237 +66563 @@
     entryPoints: [fileName],
     write: false,
-    target: ["node18"],
+    target: [`node${process.versions.node}`],
     platform: "node",
     bundle: true,
@@ -66306 +66632 @@
                       `Failed to resolve ${JSON.stringify(
                         id
-                      )}. This package is ESM only but it was tried to load by \`require\`. See https://vitejs.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
+                      )}. This package is ESM only but it was tried to load by \`require\`. See https://vite.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
                     );
                   }
@@ -66319 +66645 @@
                   `${JSON.stringify(
                     id
-                  )} resolved to an ESM file. ESM file cannot be loaded by \`require\`. See https://vitejs.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
+                  )} resolved to an ESM file. ESM file cannot be loaded by \`require\`. See https://vite.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
                 );
               }