vite 5.4.0-beta.0 → 5.4.0

package/dist/node/chunks/{dep-BuSuK4CE.js → dep-NjL7WTE1.js}

@@ -10781,17 +10781,34 @@ const glob$1 = Object.assign(glob_, {
 });
 glob$1.glob = glob$1;
 
-const comma$1 = ','.charCodeAt(0);
-const semicolon$1 = ';'.charCodeAt(0);
-const chars$2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar$1 = new Uint8Array(64); // 64 possible chars.
-const charToInt$1 = new Uint8Array(128); // z is 122 in ASCII
-for (let i = 0; i < chars$2.length; i++) {
-    const c = chars$2.charCodeAt(i);
-    intToChar$1[i] = c;
-    charToInt$1[c] = i;
-}
-function encodeInteger$1(builder, num, relative) {
+const comma = ','.charCodeAt(0);
+const semicolon = ';'.charCodeAt(0);
+const chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars$1.length; i++) {
+    const c = chars$1.charCodeAt(i);
+    intToChar[i] = c;
+    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 {
@@ -10799,14 +10816,19 @@ function encodeInteger$1(builder, num, relative) {
         delta >>>= 5;
         if (delta > 0)
             clamped |= 0b100000;
-        builder.write(intToChar$1[clamped]);
+        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$1 = typeof TextDecoder !== 'undefined'
+const td = typeof TextDecoder !== 'undefined'
     ? /* #__PURE__ */ new TextDecoder()
     : typeof Buffer !== 'undefined'
         ? {
@@ -10834,16 +10856,86 @@ class StringWriter {
         const { buffer } = this;
         buffer[this.pos++] = v;
         if (this.pos === bufLength) {
-            this.out += td$1.decode(buffer);
+            this.out += td.decode(buffer);
             this.pos = 0;
         }
     }
     flush() {
         const { buffer, out, pos } = this;
-        return pos > 0 ? out + td$1.decode(buffer.subarray(0, pos)) : out;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
     }
 }
-function encode$2(decoded) {
+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 { length } = mappings;
+    const reader = new StringReader(mappings);
+    const decoded = [];
+    let genColumn = 0;
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    do {
+        const semi = reader.indexOf(';');
+        const line = [];
+        let sorted = true;
+        let lastCol = 0;
+        genColumn = 0;
+        while (reader.pos < semi) {
+            let seg;
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
+                sorted = false;
+            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 = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+                }
+            }
+            else {
+                seg = [genColumn];
+            }
+            line.push(seg);
+            reader.pos++;
+        }
+        if (!sorted)
+            sort(line);
+        decoded.push(line);
+        reader.pos = semi + 1;
+    } while (reader.pos <= length);
+    return decoded;
+}
+function sort(line) {
+    line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+    return a[0] - b[0];
+}
+function encode$1(decoded) {
     const writer = new StringWriter();
     let sourcesIndex = 0;
     let sourceLine = 0;
@@ -10852,23 +10944,23 @@ function encode$2(decoded) {
     for (let i = 0; i < decoded.length; i++) {
         const line = decoded[i];
         if (i > 0)
-            writer.write(semicolon$1);
+            writer.write(semicolon);
         if (line.length === 0)
             continue;
         let genColumn = 0;
         for (let j = 0; j < line.length; j++) {
             const segment = line[j];
             if (j > 0)
-                writer.write(comma$1);
-            genColumn = encodeInteger$1(writer, segment[0], genColumn);
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
             if (segment.length === 1)
                 continue;
-            sourcesIndex = encodeInteger$1(writer, segment[1], sourcesIndex);
-            sourceLine = encodeInteger$1(writer, segment[2], sourceLine);
-            sourceColumn = encodeInteger$1(writer, 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;
-            namesIndex = encodeInteger$1(writer, segment[4], namesIndex);
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
         }
     }
     return writer.flush();
@@ -11088,7 +11180,7 @@ let SourceMap$1 = class SourceMap {
 		this.sources = properties.sources;
 		this.sourcesContent = properties.sourcesContent;
 		this.names = properties.names;
-		this.mappings = encode$2(properties.mappings);
+		this.mappings = encode$1(properties.mappings);
 		if (typeof properties.x_google_ignoreList !== 'undefined') {
 			this.x_google_ignoreList = properties.x_google_ignoreList;
 		}
@@ -14448,168 +14540,6 @@ function commonjs(options = {}) {
   };
 }
 
-const comma = ','.charCodeAt(0);
-const semicolon = ';'.charCodeAt(0);
-const chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar = new Uint8Array(64); // 64 possible chars.
-const charToInt = new Uint8Array(128); // z is 122 in ASCII
-for (let i = 0; i < chars$1.length; i++) {
-    const c = chars$1.charCodeAt(i);
-    intToChar[i] = c;
-    charToInt[c] = i;
-}
-// Provide a fallback for older environments.
-const td = typeof TextDecoder !== 'undefined'
-    ? /* #__PURE__ */ new TextDecoder()
-    : typeof Buffer !== 'undefined'
-        ? {
-            decode(buf) {
-                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
-                return out.toString();
-            },
-        }
-        : {
-            decode(buf) {
-                let out = '';
-                for (let i = 0; i < buf.length; i++) {
-                    out += String.fromCharCode(buf[i]);
-                }
-                return out;
-            },
-        };
-function decode(mappings) {
-    const state = new Int32Array(5);
-    const decoded = [];
-    let index = 0;
-    do {
-        const semi = indexOf(mappings, index);
-        const line = [];
-        let sorted = true;
-        let lastCol = 0;
-        state[0] = 0;
-        for (let i = index; i < semi; i++) {
-            let seg;
-            i = decodeInteger(mappings, i, state, 0); // genColumn
-            const col = state[0];
-            if (col < 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]];
-                }
-                else {
-                    seg = [col, state[1], state[2], state[3]];
-                }
-            }
-            else {
-                seg = [col];
-            }
-            line.push(seg);
-        }
-        if (!sorted)
-            sort(line);
-        decoded.push(line);
-        index = semi + 1;
-    } while (index <= mappings.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) {
-    line.sort(sortComparator$1);
-}
-function sortComparator$1(a, b) {
-    return a[0] - b[0];
-}
-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 = '';
-    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 (line.length === 0)
-            continue;
-        state[0] = 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
-            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
-            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;
-}
-
 // Matches the scheme of a URL, eg "http://"
 const schemeRegex = /^[\w+.-]+:\/\//;
 /**
@@ -20428,7 +20358,7 @@ function fileToDevUrl(id, config) {
   } else {
     rtn = path$n.posix.join(FS_PREFIX, id);
   }
-  const base = joinUrlSegments(config.server?.origin ?? "", config.base);
+  const base = joinUrlSegments(config.server?.origin ?? "", config.decodedBase);
   return joinUrlSegments(base, removeLeadingSlash(rtn));
 }
 function getPublicAssetFilename(hash, config) {
@@ -20438,7 +20368,7 @@ const publicAssetUrlCache = /* @__PURE__ */ new WeakMap();
 const publicAssetUrlRE = /__VITE_PUBLIC_ASSET__([a-z\d]{8})__/g;
 function publicFileToBuiltUrl(url, config) {
   if (config.command !== "build") {
-    return joinUrlSegments(config.base, url);
+    return joinUrlSegments(config.decodedBase, url);
   }
   const hash = getHash(url);
   let cache = publicAssetUrlCache.get(config);
@@ -27143,7 +27073,6 @@ class Collection extends NodeBase {
         }
     }
 }
-Collection.maxFlowStringSingleLineLength = 60;
 
 /**
  * Stringifies a comment.
@@ -27175,6 +27104,8 @@ const FOLD_QUOTED = 'quoted';
 function foldFlowLines(text, indent, mode = 'flow', { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
     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)
         return text;
@@ -29747,11 +29678,11 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
     let comment = '';
     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;
     let start = null;
@@ -29805,7 +29736,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
                 atNewline = true;
                 hasNewline = true;
                 if (anchor || tag)
-                    hasNewlineAfterProp = true;
+                    newlineAfterProp = token;
                 hasSpace = true;
                 break;
             case 'anchor':
@@ -29879,9 +29810,9 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
         spaceBefore,
         comment,
         hasNewline,
-        hasNewlineAfterProp,
         anchor,
         tag,
+        newlineAfterProp,
         end,
         start: start ?? end
     };
@@ -29983,7 +29914,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
                 }
                 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');
             }
         }
@@ -30337,10 +30268,23 @@ function resolveCollection(CN, ctx, token, onError, tagName, tag) {
         coll.tag = tagName;
     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'
         : token.type === 'block-seq'
@@ -30354,8 +30298,7 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
         !tagName ||
         tagName === '!' ||
         (tagName === YAMLMap.tagName && expType === 'map') ||
-        (tagName === YAMLSeq.tagName && expType === 'seq') ||
-        !expType) {
+        (tagName === YAMLSeq.tagName && expType === 'seq')) {
         return resolveCollection(CN, ctx, token, onError, tagName);
     }
     let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
@@ -30923,7 +30866,7 @@ function composeNode(ctx, token, props, onError) {
         case 'block-map':
         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);
             break;
@@ -31995,15 +31938,11 @@ class Lexer {
             if (!this.atEnd && !this.hasChars(4))
                 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';
             }
         }
         this.indentValue = yield* this.pushSpaces(false);
@@ -35215,7 +35154,7 @@ function buildHtmlPlugin(config) {
     async transform(html, id) {
       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);
         const publicToRelative = (filename, importer) => publicBase + filename;
@@ -35549,7 +35488,9 @@ ${js}`;
         return tags;
       };
       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) => {
           if (isExternalUrl(filename)) {
@@ -36346,7 +36287,9 @@ function cssPostPlugin(config) {
         const relative = config.base === "./" || config.base === "";
         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;
         };
         chunkCSS2 = chunkCSS2.replace(assetUrlRE, (_, fileHash, postfix = "") => {
@@ -36364,9 +36307,8 @@ function cssPostPlugin(config) {
           );
         });
         if (encodedPublicUrls) {
-          const relativePathToPublicFromCSS = path$n.posix.relative(
-            cssAssetDirname,
-            ""
+          const relativePathToPublicFromCSS = normalizePath$3(
+            path$n.relative(cssAssetDirname, "")
           );
           chunkCSS2 = chunkCSS2.replace(publicAssetUrlRE, (_, hash) => {
             const publicUrl = publicAssetUrlMap.get(hash).slice(1);
@@ -36988,8 +36930,8 @@ function createCachedImport(imp) {
     return cached;
   };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-C5hW-0CE.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-AVIP6AlI.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-C3NStZH1.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-DvdjAuZF.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = /* @__PURE__ */ new WeakMap();
 let alwaysFakeWorkerWorkerControllerCache;
@@ -37296,6 +37238,19 @@ ${e.message}`
     }
   }
 }
+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) {
   if (cachedSss) return cachedSss;
@@ -37410,18 +37365,18 @@ const makeModernScssWorker = (resolvers, alias, maxWorkers) => {
     () => async (sassPath, data, options) => {
       const sass = require(sassPath);
       const path2 = require("node:path");
-      const { fileURLToPath, pathToFileURL } = (
+      const { fileURLToPath: fileURLToPath2, pathToFileURL: pathToFileURL2 } = (
         // eslint-disable-next-line no-restricted-globals
         require("node:url")
       );
       const sassOptions = { ...options };
-      sassOptions.url = pathToFileURL(options.filename);
+      sassOptions.url = pathToFileURL2(options.filename);
       sassOptions.sourceMap = options.enableSourcemap;
       const internalImporter = {
         async canonicalize(url, context) {
-          const importer = context.containingUrl ? fileURLToPath(context.containingUrl) : options.filename;
+          const importer = context.containingUrl ? fileURLToPath2(context.containingUrl) : options.filename;
           const resolved = await internalCanonicalize(url, importer);
-          return resolved ? pathToFileURL(resolved) : null;
+          return resolved ? pathToFileURL2(resolved) : null;
         },
         async load(canonicalUrl) {
           const ext = path2.extname(canonicalUrl.pathname);
@@ -37432,7 +37387,7 @@ const makeModernScssWorker = (resolvers, alias, maxWorkers) => {
             syntax = "css";
           }
           const contents = await internalLoad(
-            fileURLToPath(canonicalUrl),
+            fileURLToPath2(canonicalUrl),
             options.filename
           );
           return { contents, syntax };
@@ -37447,7 +37402,7 @@ const makeModernScssWorker = (resolvers, alias, maxWorkers) => {
         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))
+          includedFiles: result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath2(url))
         }
       };
     },
@@ -37464,6 +37419,60 @@ const makeModernScssWorker = (resolvers, alias, maxWorkers) => {
   );
   return worker;
 };
+const makeModernCompilerScssWorker = (resolvers, alias, _maxWorkers) => {
+  let compiler;
+  const worker = {
+    async run(sassPath, data, options) {
+      const sass = (await import(pathToFileURL(sassPath).href)).default;
+      compiler ??= await sass.initAsyncCompiler();
+      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 };
+        }
+      };
+      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() {
+      compiler?.dispose();
+      compiler = void 0;
+    }
+  };
+  return worker;
+};
 const scssProcessor = (maxWorkers) => {
   const workerMap = /* @__PURE__ */ new Map();
   return {
@@ -37473,11 +37482,12 @@ const scssProcessor = (maxWorkers) => {
       }
     },
     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,
-          options.api === "modern" ? makeModernScssWorker(resolvers, options.alias, maxWorkers) : makeScssWorker(resolvers, options.alias, maxWorkers)
+          api === "modern-compiler" ? makeModernCompilerScssWorker(resolvers, options.alias) : api === "modern" ? makeModernScssWorker(resolvers, options.alias, maxWorkers) : makeScssWorker(resolvers, options.alias, maxWorkers)
         );
       }
       const worker = workerMap.get(options.alias);
@@ -37493,7 +37503,7 @@ const scssProcessor = (maxWorkers) => {
       };
       try {
         const result = await worker.run(
-          sassPath,
+          sassPackage.path,
           data,
           optionsWithoutAdditionalData
         );
@@ -45341,8 +45351,8 @@ function launchEditor (file, specifiedEditor, onErrorCallback) {
   // 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;
+  // Allows alphanumeric characters, periods, dashes, slashes, underscores, plus and space.
+  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())
@@ -45531,7 +45541,7 @@ const cachedFsUtilsMap = /* @__PURE__ */ new WeakMap();
 function getFsUtils(config) {
   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)) {
       fsUtils = commonFsUtils;
@@ -47642,7 +47652,7 @@ function webWorkerPlugin(config) {
         }
         if (injectEnv) {
           const s = new MagicString(raw);
-          s.prepend(injectEnv);
+          s.prepend(injectEnv + ";\n");
           return {
             code: s.toString(),
             map: s.generateMap({ hires: "boundary" })
@@ -52274,42 +52284,49 @@ Contents of line ${line}: ${code.split("\n")[line - 1]}`
 Object.defineProperty(${ssrModuleExportsKey}, "${name}", { enumerable: true, configurable: true, get(){ return ${local} }});`
     );
   }
+  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);
+          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 ast.body) {
+  for (const node of exports) {
     if (node.type === "ExportNamedDeclaration") {
       if (node.declaration) {
         if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
@@ -52703,13 +52720,13 @@ function ssrFixStacktrace(e, moduleGraph) {
 const pendingModules = /* @__PURE__ */ new Map();
 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);
   if (pending) {
     return pending;
   }
-  const modulePromise = instantiateModule(url, server, context, fixStacktrace);
+  const modulePromise = instantiateModule(url, server, fixStacktrace);
   pendingModules.set(url, modulePromise);
   modulePromise.catch(() => {
   }).finally(() => {
@@ -52717,7 +52734,7 @@ async function ssrLoadModule(url, server, context = { global }, fixStacktrace) {
   });
   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);
   if (mod.ssrError) {
@@ -52781,7 +52798,7 @@ async function instantiateModule(url, server, context = { global }, fixStacktrac
           return depSsrModule;
         }
       }
-      return ssrLoadModule(dep, server, context, fixStacktrace);
+      return ssrLoadModule(dep, server, fixStacktrace);
     } catch (err) {
       importErrors.set(err, { importee: dep });
       throw err;
@@ -52816,7 +52833,6 @@ async function instantiateModule(url, server, context = { global }, fixStacktrac
   }
   try {
     const initModule = new AsyncFunction(
-      `global`,
       ssrModuleExportsKey,
       ssrImportMetaKey,
       ssrImportKey,
@@ -52826,7 +52842,6 @@ async function instantiateModule(url, server, context = { global }, fixStacktrac
 //# sourceURL=${mod.id}${sourceMapSuffix}`
     );
     await initModule(
-      context.global,
       ssrModule,
       ssrImportMeta,
       ssrImport,
@@ -61890,7 +61905,12 @@ const processNodeUrl = (url, useSrcSetReplacer, config, htmlPath, originalUrl, s
         );
       }
       if (preTransformUrl) {
-        preTransformRequest(server, preTransformUrl, config.base);
+        try {
+          preTransformUrl = decodeURI(preTransformUrl);
+        } catch (err) {
+          return url2;
+        }
+        preTransformRequest(server, preTransformUrl, config.decodedBase);
       }
     }
     return url2;
@@ -61901,6 +61921,7 @@ const processNodeUrl = (url, useSrcSetReplacer, config, htmlPath, originalUrl, s
 const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl }) => {
   const { config, moduleGraph, watcher } = server;
   const base = config.base || "/";
+  const decodedBase = config.decodedBase || "/";
   let proxyModulePath;
   let proxyModuleUrl;
   const trailingSlash = htmlPath.endsWith("/");
@@ -61912,7 +61933,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
     proxyModulePath = `\0${validPath}`;
     proxyModuleUrl = wrapId$1(proxyModulePath);
   }
-  proxyModuleUrl = joinUrlSegments(base, proxyModuleUrl);
+  proxyModuleUrl = joinUrlSegments(decodedBase, proxyModuleUrl);
   const s = new MagicString(html);
   let inlineModuleIndex = -1;
   const proxyCacheUrl = decodeURI(
@@ -61944,7 +61965,7 @@ const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl
       node.sourceCodeLocation.endOffset,
       `<script type="module" src="${modulePath}"><\/script>`
     );
-    preTransformRequest(server, modulePath, base);
+    preTransformRequest(server, modulePath, decodedBase);
   };
   await traverseHtml(html, filename, (node) => {
     if (!nodeIsElement(node)) {
@@ -62106,14 +62127,10 @@ function indexHtmlMiddleware(root, server) {
     next();
   };
 }
-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);
 }
 
 const logTime = createDebugger("vite:time");
@@ -62709,7 +62726,7 @@ async function _createServer(inlineConfig = {}, options) {
       return devHtmlTransformFn(server, url, html, originalUrl);
     },
     async ssrLoadModule(url, opts) {
-      return ssrLoadModule(url, server, void 0, opts?.fixStacktrace);
+      return ssrLoadModule(url, server, opts?.fixStacktrace);
     },
     async ssrFetchModule(url, importer) {
       return ssrFetchModule(server, url, importer);
@@ -65616,7 +65633,7 @@ function toOutputFilePathInJS(filename, type, hostId, hostType, config, toRelati
   if (relative && !config.build.ssr) {
     return toRelative(filename, hostId);
   }
-  return joinUrlSegments(config.base, filename);
+  return joinUrlSegments(config.decodedBase, filename);
 }
 function createToImportMetaURLBasedRelativeRuntime(format, isWorker) {
   const formatLong = isWorker && format === "iife" ? "worker-iife" : format;
@@ -65653,7 +65670,7 @@ function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config
   if (relative && !config.build.ssr) {
     return toRelative(filename, hostId);
   } else {
-    return joinUrlSegments(config.base, filename);
+    return joinUrlSegments(config.decodedBase, filename);
   }
 }
 const toOutputFilePathInCss = toOutputFilePathWithoutRuntime;
@@ -66185,6 +66202,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
     plugins: createWorkerPlugins,
     rollupOptions: config.worker?.rollupOptions || {}
   };
+  const base = withTrailingSlash(resolvedBase);
   resolved = {
     configFile: configFile ? normalizePath$3(configFile) : void 0,
     configFileDependencies: configFileDependencies.map(
@@ -66192,7 +66210,8 @@ async function resolveConfig(inlineConfig, command, defaultMode = "development",
     ),
     inlineConfig,
     root: resolvedRoot,
-    base: withTrailingSlash(resolvedBase),
+    base,
+    decodedBase: decodeURI(base),
     rawBase: resolvedBase,
     resolve: resolveOptions,
     publicDir: resolvedPublicDir,