vite 2.8.0-beta.7 → 2.8.3

package/dist/node/chunks/{dep-c9c9d3e5.js → dep-f9d9421a.js}

@@ -1222,126 +1222,166 @@ const KNOWN_ASSET_TYPES = [
 const DEFAULT_ASSETS_RE = new RegExp(`\\.(` + KNOWN_ASSET_TYPES.join('|') + `)(\\?.*)?$`);
 const DEP_VERSION_RE = /[\?&](v=[\w\.-]+)\b/;
 
-var charToInteger = {};
-var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i$2 = 0; i$2 < chars$1.length; i$2++) {
-    charToInteger[chars$1.charCodeAt(i$2)] = i$2;
-}
+const comma = 44;
+const semicolon = 59;
+const chars$2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+const intToChar = new Uint8Array(65); // 65 possible chars.
+const charToInteger$1 = new Uint8Array(123); // z is 122 in ASCII
+for (let i = 0; i < chars$2.length; i++) {
+    const c = chars$2.charCodeAt(i);
+    charToInteger$1[c] = i;
+    intToChar[i] = c;
+}
+// Provide a fallback for older environments.
+const td = typeof TextDecoder !== 'undefined'
+    ? 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) {
-    var decoded = [];
-    var line = [];
-    var segment = [
-        0,
-        0,
-        0,
-        0,
-        0,
-    ];
-    var j = 0;
-    for (var i = 0, shift = 0, value = 0; i < mappings.length; i++) {
-        var c = mappings.charCodeAt(i);
-        if (c === 44) { // ","
-            segmentify(line, segment, j);
-            j = 0;
-        }
-        else if (c === 59) { // ";"
-            segmentify(line, segment, j);
-            j = 0;
+    const state = new Int32Array(5);
+    const decoded = [];
+    let line = [];
+    let sorted = true;
+    let lastCol = 0;
+    for (let i = 0; i < mappings.length;) {
+        const c = mappings.charCodeAt(i);
+        if (c === comma) {
+            i++;
+        }
+        else if (c === semicolon) {
+            state[0] = lastCol = 0;
+            if (!sorted)
+                sort(line);
+            sorted = true;
             decoded.push(line);
             line = [];
-            segment[0] = 0;
+            i++;
         }
         else {
-            var integer = charToInteger[c];
-            if (integer === undefined) {
-                throw new Error('Invalid character (' + String.fromCharCode(c) + ')');
-            }
-            var hasContinuationBit = integer & 32;
-            integer &= 31;
-            value += integer << shift;
-            if (hasContinuationBit) {
-                shift += 5;
+            i = decodeInteger(mappings, i, state, 0); // generatedCodeColumn
+            const col = state[0];
+            if (col < lastCol)
+                sorted = false;
+            lastCol = col;
+            if (!hasMoreSegments(mappings, i)) {
+                line.push([col]);
+                continue;
             }
-            else {
-                var shouldNegate = value & 1;
-                value >>>= 1;
-                if (shouldNegate) {
-                    value = value === 0 ? -0x80000000 : -value;
-                }
-                segment[j] += value;
-                j++;
-                value = shift = 0; // reset
+            i = decodeInteger(mappings, i, state, 1); // sourceFileIndex
+            i = decodeInteger(mappings, i, state, 2); // sourceCodeLine
+            i = decodeInteger(mappings, i, state, 3); // sourceCodeColumn
+            if (!hasMoreSegments(mappings, i)) {
+                line.push([col, state[1], state[2], state[3]]);
+                continue;
             }
+            i = decodeInteger(mappings, i, state, 4); // nameIndex
+            line.push([col, state[1], state[2], state[3], state[4]]);
         }
     }
-    segmentify(line, segment, j);
+    if (!sorted)
+        sort(line);
     decoded.push(line);
     return decoded;
 }
-function segmentify(line, segment, j) {
-    // This looks ugly, but we're creating specialized arrays with a specific
-    // length. This is much faster than creating a new array (which v8 expands to
-    // a capacity of 17 after pushing the first item), or slicing out a subarray
-    // (which is slow). Length 4 is assumed to be the most frequent, followed by
-    // length 5 (since not everything will have an associated name), followed by
-    // length 1 (it's probably rare for a source substring to not have an
-    // associated segment data).
-    if (j === 4)
-        line.push([segment[0], segment[1], segment[2], segment[3]]);
-    else if (j === 5)
-        line.push([segment[0], segment[1], segment[2], segment[3], segment[4]]);
-    else if (j === 1)
-        line.push([segment[0]]);
+function decodeInteger(mappings, pos, state, j) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = mappings.charCodeAt(pos++);
+        integer = charToInteger$1[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = value === 0 ? -0x80000000 : -value;
+    }
+    state[j] += value;
+    return pos;
+}
+function hasMoreSegments(mappings, i) {
+    if (i >= mappings.length)
+        return false;
+    const c = mappings.charCodeAt(i);
+    if (c === comma || c === semicolon)
+        return false;
+    return true;
 }
-function encode(decoded) {
-    var sourceFileIndex = 0; // second field
-    var sourceCodeLine = 0; // third field
-    var sourceCodeColumn = 0; // fourth field
-    var nameIndex = 0; // fifth field
-    var mappings = '';
-    for (var i = 0; i < decoded.length; i++) {
-        var line = decoded[i];
-        if (i > 0)
-            mappings += ';';
+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);
+    let buf = new Uint8Array(1000);
+    let pos = 0;
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        if (i > 0) {
+            buf = reserve(buf, pos, 1);
+            buf[pos++] = semicolon;
+        }
         if (line.length === 0)
             continue;
-        var generatedCodeColumn = 0; // first field
-        var lineMappings = [];
-        for (var _i = 0, line_1 = line; _i < line_1.length; _i++) {
-            var segment = line_1[_i];
-            var segmentMappings = encodeInteger(segment[0] - generatedCodeColumn);
-            generatedCodeColumn = segment[0];
-            if (segment.length > 1) {
-                segmentMappings +=
-                    encodeInteger(segment[1] - sourceFileIndex) +
-                        encodeInteger(segment[2] - sourceCodeLine) +
-                        encodeInteger(segment[3] - sourceCodeColumn);
-                sourceFileIndex = segment[1];
-                sourceCodeLine = segment[2];
-                sourceCodeColumn = segment[3];
-            }
-            if (segment.length === 5) {
-                segmentMappings += encodeInteger(segment[4] - nameIndex);
-                nameIndex = segment[4];
-            }
-            lineMappings.push(segmentMappings);
+        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.
+            buf = reserve(buf, pos, 36);
+            if (j > 0)
+                buf[pos++] = comma;
+            pos = encodeInteger$1(buf, pos, state, segment, 0); // generatedCodeColumn
+            if (segment.length === 1)
+                continue;
+            pos = encodeInteger$1(buf, pos, state, segment, 1); // sourceFileIndex
+            pos = encodeInteger$1(buf, pos, state, segment, 2); // sourceCodeLine
+            pos = encodeInteger$1(buf, pos, state, segment, 3); // sourceCodeColumn
+            if (segment.length === 4)
+                continue;
+            pos = encodeInteger$1(buf, pos, state, segment, 4); // nameIndex
         }
-        mappings += lineMappings.join(',');
     }
-    return mappings;
+    return td.decode(buf.subarray(0, pos));
 }
-function encodeInteger(num) {
-    var result = '';
+function reserve(buf, pos, count) {
+    if (buf.length > pos + count)
+        return buf;
+    const swap = new Uint8Array(buf.length * 2);
+    swap.set(buf);
+    return swap;
+}
+function encodeInteger$1(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 {
-        var clamped = num & 31;
+        let clamped = num & 31;
         num >>>= 5;
-        if (num > 0) {
+        if (num > 0)
             clamped |= 32;
-        }
-        result += chars$1[clamped];
+        buf[pos++] = intToChar[clamped];
     } while (num > 0);
-    return result;
+    return pos;
 }
 
 // Matches the scheme of a URL, eg "http://"
@@ -1519,199 +1559,82 @@ function resolve$3(input, base) {
     return `${url.scheme}//${url.user}${url.host}${url.port}${url.path}`;
 }
 
-/**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Creates a brand new (prototype-less) object with the enumerable-own
- * properties of `target`. Any enumerable-own properties from `source` which
- * are not present on `target` will be copied as well.
- */
-function defaults(target, source) {
-    return Object.assign(Object.create(null), source, target);
+function resolve$2(input, base) {
+    // The base is always treated as a directory, if it's not empty.
+    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
+    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
+    if (base && !base.endsWith('/'))
+        base += '/';
+    return resolve$3(input, base);
 }
 
 /**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Decodes an input sourcemap into a `DecodedSourceMap` sourcemap object.
- *
- * Valid input maps include a `DecodedSourceMap`, a `RawSourceMap`, or JSON
- * representations of either type.
+ * Removes everything after the last "/", but leaves the slash.
  */
-function decodeSourceMap(map) {
-    if (typeof map === 'string') {
-        map = JSON.parse(map);
-    }
-    let { mappings } = map;
-    if (typeof mappings === 'string') {
-        mappings = sortMappings(decode(mappings), true);
-    }
-    else {
-        // Clone the Line so that we can sort it. We don't want to mutate an array
-        // that we don't own directly.
-        mappings = sortMappings(mappings, false);
-    }
-    return defaults({ mappings }, map);
-}
-function firstUnsortedSegmentLine(mappings) {
-    for (let i = 0; i < mappings.length; i++) {
-        const segments = mappings[i];
-        for (let j = 1; j < segments.length; j++) {
-            if (segments[j][0] < segments[j - 1][0]) {
-                return i;
-            }
-        }
-    }
-    return mappings.length;
+function stripFilename(path) {
+    if (!path)
+        return '';
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
 }
-function sortMappings(mappings, owned) {
-    const unosrtedIndex = firstUnsortedSegmentLine(mappings);
-    if (unosrtedIndex === mappings.length)
+
+function maybeSort(mappings, owned) {
+    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+    if (unsortedIndex === mappings.length)
         return mappings;
+    // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
+    // not, we do not want to modify the consumer's input array.
     if (!owned)
         mappings = mappings.slice();
-    for (let i = unosrtedIndex; i < mappings.length; i++) {
+    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
         mappings[i] = sortSegments(mappings[i], owned);
     }
     return mappings;
 }
-function sortSegments(segments, owned) {
-    if (!owned)
-        segments = segments.slice();
-    return segments.sort(segmentComparator);
-}
-function segmentComparator(a, b) {
-    return a[0] - b[0];
-}
-
-/**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * A "leaf" node in the sourcemap tree, representing an original, unmodified
- * source file. Recursive segment tracing ends at the `OriginalSource`.
- */
-class OriginalSource {
-    constructor(filename, content) {
-        this.filename = filename;
-        this.content = content;
+function nextUnsortedSegmentLine(mappings, start) {
+    for (let i = start; i < mappings.length; i++) {
+        if (!isSorted(mappings[i]))
+            return i;
     }
-    /**
-     * Tracing a `SourceMapSegment` ends when we get to an `OriginalSource`,
-     * meaning this line/column location originated from this source file.
-     */
-    traceSegment(line, column, name) {
-        return { column, line, name, source: this };
+    return mappings.length;
+}
+function isSorted(line) {
+    for (let j = 1; j < line.length; j++) {
+        if (line[j][0] < line[j - 1][0]) {
+            return false;
+        }
     }
+    return true;
 }
-
-/**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function resolve$2(input, base) {
-    // The base is always treated as a directory, if it's not empty.
-    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
-    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
-    if (base && !base.endsWith('/'))
-        base += '/';
-    return resolve$3(input, base);
+function sortSegments(line, owned) {
+    if (!owned)
+        line = line.slice();
+    return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[0] - b[0];
 }
 
 /**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * A binary search implementation that returns the index if a match is found,
- * or the negated index of where the `needle` should be inserted.
- *
- * The `comparator` callback receives both the `item` under comparison and the
- * needle we are searching for. It must return `0` if the `item` is a match,
- * any negative number if `item` is too small (and we must search after it), or
- * any positive number if the `item` is too large (and we must search before
- * it).
- *
- * If no match is found, a negated index of where to insert the `needle` is
- * returned. This negated index is guaranteed to be less than 0. To insert an
- * item, negate it (again) and splice:
+ * A binary search implementation that returns the index if a match is found.
+ * If no match is found, then the left-index (the index associated with the item that comes just
+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+ * the next index:
  *
  * ```js
  * const array = [1, 3];
  * const needle = 2;
  * const index = binarySearch(array, needle, (item, needle) => item - needle);
  *
- * assert.equal(index, -2);
- * assert.equal(~index, 1);
- * array.splice(~index, 0, needle);
+ * assert.equal(index, 0);
+ * array.splice(index + 1, 0, needle);
  * assert.deepEqual(array, [1, 2, 3]);
  * ```
  */
-function binarySearch$2(haystack, needle, comparator, low, high) {
-    low = Math.max(low, 0);
+function binarySearch$2(haystack, needle, low, high) {
     while (low <= high) {
         const mid = low + ((high - low) >> 1);
-        const cmp = comparator(haystack[mid], needle);
+        const cmp = haystack[mid][0] - needle;
         if (cmp === 0) {
             return mid;
         }
@@ -1722,24 +1645,147 @@ function binarySearch$2(haystack, needle, comparator, low, high) {
             high = mid - 1;
         }
     }
-    return ~low;
+    return low - 1;
+}
+function memoizedState() {
+    return {
+        lastKey: -1,
+        lastNeedle: -1,
+        lastIndex: -1,
+    };
+}
+/**
+ * This overly complicated beast is just to record the last tested line/column and the resulting
+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
+ */
+function memoizedBinarySearch(haystack, needle, state, key) {
+    const { lastKey, lastNeedle, lastIndex } = state;
+    let low = 0;
+    let high = haystack.length - 1;
+    if (key === lastKey) {
+        if (needle === lastNeedle) {
+            return lastIndex;
+        }
+        if (needle >= lastNeedle) {
+            // lastIndex may be -1 if the previous needle was not found.
+            low = Math.max(lastIndex, 0);
+        }
+        else {
+            high = lastIndex;
+        }
+    }
+    state.lastKey = key;
+    state.lastNeedle = needle;
+    return (state.lastIndex = binarySearch$2(haystack, needle, low, high));
 }
 
+Object.freeze({
+    source: null,
+    line: null,
+    column: null,
+    name: null,
+});
 /**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+ */
+let encodedMappings;
+/**
+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+ */
+let decodedMappings;
+/**
+ * A low-level API to find the segment associated with a generated line/column (think, from a
+ * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
+ */
+let traceSegment;
+/**
+ * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
+ * maps.
+ */
+let presortedDecodedMap;
+class TraceMap {
+    constructor(map, mapUrl) {
+        this._binarySearchMemo = memoizedState();
+        const isString = typeof map === 'string';
+        const parsed = isString ? JSON.parse(map) : map;
+        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+        this.version = version;
+        this.file = file;
+        this.names = names;
+        this.sourceRoot = sourceRoot;
+        this.sources = sources;
+        this.sourcesContent = sourcesContent;
+        if (sourceRoot || mapUrl) {
+            const from = resolve$2(sourceRoot || '', stripFilename(mapUrl));
+            this.resolvedSources = sources.map((s) => resolve$2(s || '', from));
+        }
+        else {
+            this.resolvedSources = sources;
+        }
+        const { mappings } = parsed;
+        if (typeof mappings === 'string') {
+            this._encoded = mappings;
+            this._decoded = decode(mappings);
+        }
+        else {
+            this._encoded = undefined;
+            this._decoded = maybeSort(mappings, isString);
+        }
+    }
+}
+(() => {
+    encodedMappings = (map) => {
+        var _a;
+        return ((_a = map._encoded) !== null && _a !== void 0 ? _a : (map._encoded = encode$1(map._decoded)));
+    };
+    decodedMappings = (map) => {
+        return map._decoded;
+    };
+    traceSegment = (map, line, column) => {
+        const decoded = map._decoded;
+        // It's common for parent source maps to have pointers to lines that have no
+        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+        if (line >= decoded.length)
+            return null;
+        const segments = decoded[line];
+        const index = memoizedBinarySearch(segments, column, map._binarySearchMemo, line);
+        // we come before any mapped segment
+        if (index < 0)
+            return null;
+        return segments[index];
+    };
+    presortedDecodedMap = (map, mapUrl) => {
+        const clone = Object.assign({}, map);
+        clone.mappings = [];
+        const tracer = new TraceMap(clone, mapUrl);
+        tracer._decoded = map.mappings;
+        return tracer;
+    };
+})();
+
+/**
+ * A "leaf" node in the sourcemap tree, representing an original, unmodified
+ * source file. Recursive segment tracing ends at the `OriginalSource`.
+ */
+class OriginalSource {
+    constructor(source, content) {
+        this.source = source;
+        this.content = content;
+    }
+    /**
+     * Tracing a `SourceMapSegment` ends when we get to an `OriginalSource`,
+     * meaning this line/column location originated from this source file.
+     */
+    originalPositionFor(line, column, name) {
+        return { column, line, name, source: this.source, content: this.content };
+    }
+}
+
+/**
+ * Puts `key` into the backing array, if it is not already present. Returns
+ * the index of the `key` in the backing array.
  */
+let put;
 /**
  * FastStringArray acts like a `Set` (allowing only one occurrence of a string
  * `key`), but provides the index of the `key` in the backing array.
@@ -1753,12 +1799,10 @@ class FastStringArray {
         this.indexes = Object.create(null);
         this.array = [];
     }
-    /**
-     * Puts `key` into the backing array, if it is not already present. Returns
-     * the index of the `key` in the backing array.
-     */
-    put(key) {
-        const { array, indexes } = this;
+}
+(() => {
+    put = (strarr, key) => {
+        const { array, indexes } = strarr;
         // The key may or may not be present. If it is present, it's a number.
         let index = indexes[key];
         // If it's not yet present, we need to insert it and track the index in the
@@ -1768,24 +1812,16 @@ class FastStringArray {
             array.push(key);
         }
         return index;
-    }
-}
+    };
+})();
 
+const INVALID_MAPPING = undefined;
+const SOURCELESS_MAPPING = null;
 /**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * traceMappings is only called on the root level SourceMapTree, and begins the process of
+ * resolving each mapping in terms of the original source files.
  */
+let traceMappings;
 /**
  * SourceMapTree represents a single sourcemap, with the ability to trace
  * mappings into its child nodes (which may themselves be SourceMapTrees).
@@ -1794,166 +1830,105 @@ class SourceMapTree {
     constructor(map, sources) {
         this.map = map;
         this.sources = sources;
-        this.lastLine = 0;
-        this.lastColumn = 0;
-        this.lastIndex = 0;
     }
     /**
-     * traceMappings is only called on the root level SourceMapTree, and begins
-     * the process of resolving each mapping in terms of the original source
-     * files.
+     * originalPositionFor is only called on children SourceMapTrees. It recurses down
+     * into its own child SourceMapTrees, until we find the original source map.
      */
-    traceMappings() {
+    originalPositionFor(line, column, name) {
+        const segment = traceSegment(this.map, line, column);
+        // If we couldn't find a segment, then this doesn't exist in the sourcemap.
+        if (segment == null)
+            return INVALID_MAPPING;
+        // 1-length segments only move the current generated column, there's no source information
+        // to gather from it.
+        if (segment.length === 1)
+            return SOURCELESS_MAPPING;
+        const source = this.sources[segment[1]];
+        return source.originalPositionFor(segment[2], segment[3], segment.length === 5 ? this.map.names[segment[4]] : name);
+    }
+}
+(() => {
+    traceMappings = (tree) => {
         const mappings = [];
         const names = new FastStringArray();
         const sources = new FastStringArray();
         const sourcesContent = [];
-        const { mappings: rootMappings, names: rootNames } = this.map;
+        const { sources: rootSources, map } = tree;
+        const rootNames = map.names;
+        const rootMappings = decodedMappings(map);
+        let lastLineWithSegment = -1;
         for (let i = 0; i < rootMappings.length; i++) {
             const segments = rootMappings[i];
             const tracedSegments = [];
-            let lastTraced = undefined;
+            let lastSourcesIndex = -1;
+            let lastSourceLine = -1;
+            let lastSourceColumn = -1;
             for (let j = 0; j < segments.length; j++) {
                 const segment = segments[j];
-                // 1-length segments only move the current generated column, there's no
-                // source information to gather from it.
-                if (segment.length === 1)
-                    continue;
-                const source = this.sources[segment[1]];
-                const traced = source.traceSegment(segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : '');
-                if (!traced)
+                let traced = SOURCELESS_MAPPING;
+                // 1-length segments only move the current generated column, there's no source information
+                // to gather from it.
+                if (segment.length !== 1) {
+                    const source = rootSources[segment[1]];
+                    traced = source.originalPositionFor(segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : '');
+                    // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a
+                    // respective segment into an original source.
+                    if (traced === INVALID_MAPPING)
+                        continue;
+                }
+                const genCol = segment[0];
+                if (traced === SOURCELESS_MAPPING) {
+                    if (lastSourcesIndex === -1) {
+                        // This is a consecutive source-less segment, which doesn't carry any new information.
+                        continue;
+                    }
+                    lastSourcesIndex = lastSourceLine = lastSourceColumn = -1;
+                    tracedSegments.push([genCol]);
                     continue;
+                }
                 // So we traced a segment down into its original source file. Now push a
                 // new segment pointing to this location.
-                const { column, line, name } = traced;
-                const { content, filename } = traced.source;
+                const { column, line, name, content, source } = traced;
                 // Store the source location, and ensure we keep sourcesContent up to
                 // date with the sources array.
-                const sourceIndex = sources.put(filename);
-                sourcesContent[sourceIndex] = content;
-                if (lastTraced &&
-                    lastTraced[1] === sourceIndex &&
-                    lastTraced[2] === line &&
-                    lastTraced[3] === column) {
-                    // This is a duplicate mapping pointing at the exact same starting point in the source file.
-                    // It doesn't provide any new information, and only bloats the sourcemap.
+                const sourcesIndex = put(sources, source);
+                sourcesContent[sourcesIndex] = content;
+                if (lastSourcesIndex === sourcesIndex &&
+                    lastSourceLine === line &&
+                    lastSourceColumn === column) {
+                    // This is a duplicate mapping pointing at the exact same starting point in the source
+                    // file. It doesn't carry any new information, and only bloats the sourcemap.
                     continue;
                 }
-                // This looks like unnecessary duplication, but it noticeably increases
-                // performance. If we were to push the nameIndex onto length-4 array, v8
-                // would internally allocate 22 slots! That's 68 wasted bytes! Array
-                // literals have the same capacity as their length, saving memory.
-                if (name) {
-                    lastTraced = [segment[0], sourceIndex, line, column, names.put(name)];
-                }
-                else {
-                    lastTraced = [segment[0], sourceIndex, line, column];
-                }
-                tracedSegments.push(lastTraced);
+                lastLineWithSegment = i;
+                lastSourcesIndex = sourcesIndex;
+                lastSourceLine = line;
+                lastSourceColumn = column;
+                // This looks like unnecessary duplication, but it noticeably increases performance. If we
+                // were to push the nameIndex onto length-4 array, v8 would internally allocate 22 slots!
+                // That's 68 wasted bytes! Array literals have the same capacity as their length, saving
+                // memory.
+                tracedSegments.push(name
+                    ? [genCol, sourcesIndex, line, column, put(names, name)]
+                    : [genCol, sourcesIndex, line, column]);
             }
             mappings.push(tracedSegments);
         }
-        // TODO: Make all sources relative to the sourceRoot.
-        return defaults({
+        if (mappings.length > lastLineWithSegment + 1) {
+            mappings.length = lastLineWithSegment + 1;
+        }
+        return presortedDecodedMap(Object.assign({}, tree.map, {
             mappings,
+            // TODO: Make all sources relative to the sourceRoot.
+            sourceRoot: undefined,
             names: names.array,
             sources: sources.array,
             sourcesContent,
-        }, this.map);
-    }
-    /**
-     * traceSegment is only called on children SourceMapTrees. It recurses down
-     * into its own child SourceMapTrees, until we find the original source map.
-     */
-    traceSegment(line, column, name) {
-        const { mappings, names } = this.map;
-        // It's common for parent sourcemaps to have pointers to lines that have no
-        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
-        if (line >= mappings.length)
-            return null;
-        const segments = mappings[line];
-        if (segments.length === 0)
-            return null;
-        let low = 0;
-        let high = segments.length - 1;
-        if (line === this.lastLine) {
-            if (column >= this.lastColumn) {
-                low = this.lastIndex;
-            }
-            else {
-                high = this.lastIndex;
-            }
-        }
-        let index = binarySearch$2(segments, column, segmentComparator$1, low, high);
-        this.lastLine = line;
-        this.lastColumn = column;
-        if (index === -1) {
-            this.lastIndex = index;
-            return null; // we come before any mapped segment
-        }
-        // If we can't find a segment that lines up to this column, we use the
-        // segment before.
-        if (index < 0) {
-            index = ~index - 1;
-        }
-        this.lastIndex = index;
-        const segment = segments[index];
-        // 1-length segments only move the current generated column, there's no
-        // source information to gather from it.
-        if (segment.length === 1)
-            return null;
-        const source = this.sources[segment[1]];
-        // So now we can recurse down, until we hit the original source file.
-        return source.traceSegment(segment[2], segment[3], 
-        // A child map's recorded name for this segment takes precedence over the
-        // parent's mapped name. Imagine a mangler changing the name over, etc.
-        segment.length === 5 ? names[segment[4]] : name);
-    }
-}
-function segmentComparator$1(segment, column) {
-    return segment[0] - column;
-}
-
-/**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Removes the filename from a path.
- */
-function stripFilename(path) {
-    if (!path)
-        return '';
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
-}
+        }));
+    };
+})();
 
-/**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 function asArray(value) {
     if (Array.isArray(value))
         return value;
@@ -1970,8 +1945,8 @@ function asArray(value) {
  * does not have an associated sourcemap, it is considered an original,
  * unmodified source file.
  */
-function buildSourceMapTree(input, loader, relativeRoot) {
-    const maps = asArray(input).map(decodeSourceMap);
+function buildSourceMapTree(input, loader) {
+    const maps = asArray(input).map((m) => new TraceMap(m, ''));
     const map = maps.pop();
     for (let i = 0; i < maps.length; i++) {
         if (maps[i].sources.length > 1) {
@@ -1979,48 +1954,43 @@ function buildSourceMapTree(input, loader, relativeRoot) {
                 'Did you specify these with the most recent transformation maps first?');
         }
     }
-    const { sourceRoot, sources, sourcesContent } = map;
-    const children = sources.map((sourceFile, i) => {
-        // Each source file is loaded relative to the sourcemap's own sourceRoot,
-        // which is itself relative to the sourcemap's parent.
-        const uri = resolve$2(sourceFile || '', resolve$2(sourceRoot || '', stripFilename(relativeRoot)));
+    let tree = build$2(map, '', loader);
+    for (let i = maps.length - 1; i >= 0; i--) {
+        tree = new SourceMapTree(maps[i], [tree]);
+    }
+    return tree;
+}
+function build$2(map, importer, loader) {
+    const { resolvedSources, sourcesContent } = map;
+    const children = resolvedSources.map((sourceFile, i) => {
+        // The loading context gives the loader more information about why this file is being loaded
+        // (eg, from which importer). It also allows the loader to override the location of the loaded
+        // sourcemap/original source, or to override the content in the sourcesContent field if it's
+        // an unmodified source file.
+        const ctx = {
+            importer,
+            source: sourceFile || '',
+            content: undefined,
+        };
         // Use the provided loader callback to retrieve the file's sourcemap.
         // TODO: We should eventually support async loading of sourcemap files.
-        const sourceMap = loader(uri);
+        const sourceMap = loader(ctx.source, ctx);
+        const { source, content } = ctx;
         // If there is no sourcemap, then it is an unmodified source file.
         if (!sourceMap) {
-            // The source file's actual contents must be included in the sourcemap
-            // (done when generating the sourcemap) for it to be included as a
-            // sourceContent in the output sourcemap.
-            const sourceContent = sourcesContent ? sourcesContent[i] : null;
-            return new OriginalSource(uri, sourceContent);
+            // The contents of this unmodified source file can be overridden via the loader context,
+            // allowing it to be explicitly null or a string. If it remains undefined, we fall back to
+            // the importing sourcemap's `sourcesContent` field.
+            const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;
+            return new OriginalSource(source, sourceContent);
         }
         // Else, it's a real sourcemap, and we need to recurse into it to load its
         // source files.
-        return buildSourceMapTree(decodeSourceMap(sourceMap), loader, uri);
+        return build$2(new TraceMap(sourceMap, source), source, loader);
     });
-    let tree = new SourceMapTree(map, children);
-    for (let i = maps.length - 1; i >= 0; i--) {
-        tree = new SourceMapTree(maps[i], [tree]);
-    }
-    return tree;
+    return new SourceMapTree(map, children);
 }
 
-/**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
  * A SourceMap v3 compatible sourcemap, which only includes fields that were
  * provided to it.
@@ -2028,13 +1998,10 @@ function buildSourceMapTree(input, loader, relativeRoot) {
 class SourceMap$1 {
     constructor(map, options) {
         this.version = 3; // SourceMap spec says this should be first.
-        if ('file' in map)
-            this.file = map.file;
-        this.mappings = options.decodedMappings ? map.mappings : encode(map.mappings);
+        this.file = map.file;
+        this.mappings = options.decodedMappings ? decodedMappings(map) : encodedMappings(map);
         this.names = map.names;
-        // TODO: We first need to make all source URIs relative to the sourceRoot
-        // before we can support a sourceRoot.
-        // if ('sourceRoot' in map) this.sourceRoot = map.sourceRoot;
+        this.sourceRoot = map.sourceRoot;
         this.sources = map.sources;
         if (!options.excludeContent && 'sourcesContent' in map) {
             this.sourcesContent = map.sourcesContent;
@@ -2045,21 +2012,6 @@ class SourceMap$1 {
     }
 }
 
-/**
- * Copyright 2019 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
  * Traces through all the mappings in the root sourcemap, through the sources
  * (and their sourcemaps), all the way back to the original source location.
@@ -2077,8 +2029,8 @@ class SourceMap$1 {
  */
 function remapping(input, loader, options) {
     const opts = typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false };
-    const graph = buildSourceMapTree(input, loader);
-    return new SourceMap$1(graph.traceMappings(), opts);
+    const tree = buildSourceMapTree(input, loader);
+    return new SourceMap$1(traceMappings(tree), opts);
 }
 
 function slash$1(p) {
@@ -2225,7 +2177,7 @@ function injectQuery(url, queryToInject) {
         pathname = pathname.slice(1);
     }
     pathname = decodeURIComponent(pathname);
-    return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ''}${hash || ''}`;
+    return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ''}${hash !== null && hash !== void 0 ? hash : ''}`;
 }
 const timestampRE = /\bt=\d{13}&?\b/;
 function removeTimestampQuery(url) {
@@ -2386,8 +2338,8 @@ function writeFile(filename, content) {
  */
 function isFileReadable(filename) {
     try {
-        fs__default.accessSync(filename, fs__default.constants.R_OK);
-        return true;
+        const stat = fs__default.statSync(filename, { throwIfNoEntry: false });
+        return !!stat;
     }
     catch {
         return false;
@@ -2463,7 +2415,7 @@ async function processSrcSet(srcs, replacer) {
         };
     }));
     return ret.reduce((prev, { url, descriptor }, index) => {
-        descriptor = descriptor || '';
+        descriptor !== null && descriptor !== void 0 ? descriptor : (descriptor = '');
         return (prev +=
             url + ` ${descriptor}${index === ret.length - 1 ? '' : ', '}`);
     }, '');
@@ -2858,6 +2810,62 @@ function throttle(fn) {
     };
 }
 
+var charToInteger = {};
+var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+for (var i$2 = 0; i$2 < chars$1.length; i$2++) {
+    charToInteger[chars$1.charCodeAt(i$2)] = i$2;
+}
+function encode(decoded) {
+    var sourceFileIndex = 0; // second field
+    var sourceCodeLine = 0; // third field
+    var sourceCodeColumn = 0; // fourth field
+    var nameIndex = 0; // fifth field
+    var mappings = '';
+    for (var i = 0; i < decoded.length; i++) {
+        var line = decoded[i];
+        if (i > 0)
+            mappings += ';';
+        if (line.length === 0)
+            continue;
+        var generatedCodeColumn = 0; // first field
+        var lineMappings = [];
+        for (var _i = 0, line_1 = line; _i < line_1.length; _i++) {
+            var segment = line_1[_i];
+            var segmentMappings = encodeInteger(segment[0] - generatedCodeColumn);
+            generatedCodeColumn = segment[0];
+            if (segment.length > 1) {
+                segmentMappings +=
+                    encodeInteger(segment[1] - sourceFileIndex) +
+                        encodeInteger(segment[2] - sourceCodeLine) +
+                        encodeInteger(segment[3] - sourceCodeColumn);
+                sourceFileIndex = segment[1];
+                sourceCodeLine = segment[2];
+                sourceCodeColumn = segment[3];
+            }
+            if (segment.length === 5) {
+                segmentMappings += encodeInteger(segment[4] - nameIndex);
+                nameIndex = segment[4];
+            }
+            lineMappings.push(segmentMappings);
+        }
+        mappings += lineMappings.join(',');
+    }
+    return mappings;
+}
+function encodeInteger(num) {
+    var result = '';
+    num = num < 0 ? (-num << 1) | 1 : num << 1;
+    do {
+        var clamped = num & 31;
+        num >>>= 5;
+        if (num > 0) {
+            clamped |= 32;
+        }
+        result += chars$1[clamped];
+    } while (num > 0);
+    return result;
+}
+
 var BitSet = function BitSet(arg) {
 	this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
 };
@@ -5660,7 +5668,7 @@ const append$1 = (queue = '', stash = '', enclose = false) => {
   return utils$g.flatten(result);
 };
 
-const expand$4 = (ast, options = {}) => {
+const expand$3 = (ast, options = {}) => {
   let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
 
   let walk = (node, parent = {}) => {
@@ -5740,7 +5748,7 @@ const expand$4 = (ast, options = {}) => {
   return utils$g.flatten(walk(ast));
 };
 
-var expand_1$1 = expand$4;
+var expand_1 = expand$3;
 
 var constants$6 = {
   MAX_LENGTH: 1024 * 64,
@@ -6129,7 +6137,7 @@ var parse_1$2 = parse$m;
 
 const stringify$4 = stringify$8;
 const compile = compile_1;
-const expand$3 = expand_1$1;
+const expand$2 = expand_1;
 const parse$l = parse_1$2;
 
 /**
@@ -6249,7 +6257,7 @@ braces$2.expand = (input, options = {}) => {
     input = braces$2.parse(input, options);
   }
 
-  let result = expand$3(input, options);
+  let result = expand$2(input, options);
 
   // filter out empty strings if specified
   if (options.noempty === true) {
@@ -18858,7 +18866,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
     const postcssOptions = (postcssConfig && postcssConfig.options) || {};
     const postcssPlugins = postcssConfig && postcssConfig.plugins ? postcssConfig.plugins.slice() : [];
     if (needInlineImport) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-0ebab0df.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-ec2e68f4.js'); }).then(function (n) { return n.index; })).default({
             async resolve(id, basedir) {
                 const resolved = await atImportResolvers.css(id, path__default.join(basedir, '*'));
                 if (resolved) {
@@ -18872,7 +18880,7 @@ async function compileCSS(id, code, config, urlReplacer, atImportResolvers, serv
         replacer: urlReplacer
     }));
     if (isModule) {
-        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-752d5fd3.js'); }).then(function (n) { return n.index; })).default({
+        postcssPlugins.unshift((await Promise.resolve().then(function () { return require('./dep-cc251a32.js'); }).then(function (n) { return n.index; })).default({
             ...modulesOptions,
             getJSON(cssFileName, _modules, outputFileName) {
                 modules = _modules;
@@ -21295,7 +21303,7 @@ const assetAttrsConfig = {
 const isAsyncScriptMap = new WeakMap();
 async function traverseHtml(html, filePath, visitor) {
     // lazy load compiler
-    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-9e561a04.js'); }).then(function (n) { return n.compilerDom_cjs; });
+    const { parse, transform } = await Promise.resolve().then(function () { return require('./dep-d44e59ba.js'); }).then(function (n) { return n.compilerDom_cjs; });
     // @vue/compiler-core doesn't like lowercase doctypes
     html = html.replace(/<!doctype\s/i, '<!DOCTYPE ');
     try {
@@ -22780,7 +22788,9 @@ function manifestPlugin(config) {
             const outputLength = Array.isArray(output) ? output.length : 1;
             if (outputCount >= outputLength) {
                 this.emitFile({
-                    fileName: `manifest.json`,
+                    fileName: typeof config.build.manifest === 'string'
+                        ? config.build.manifest
+                        : 'manifest.json',
                     type: 'asset',
                     source: JSON.stringify(manifest, null, 2)
                 });
@@ -23682,7 +23692,7 @@ function expandTop(str) {
     str = '\\{\\}' + str.substr(2);
   }
 
-  return expand$2(escapeBraces(str), true).map(unescapeBraces);
+  return expand$1(escapeBraces(str), true).map(unescapeBraces);
 }
 
 function embrace(str) {
@@ -23699,7 +23709,7 @@ function gte(i, y) {
   return i >= y;
 }
 
-function expand$2(str, isTop) {
+function expand$1(str, isTop) {
   var expansions = [];
 
   var m = balanced('{', '}', str);
@@ -23713,7 +23723,7 @@ function expand$2(str, isTop) {
     // {a},b}
     if (m.post.match(/,.*\}/)) {
       str = m.pre + '{' + m.body + escClose + m.post;
-      return expand$2(str);
+      return expand$1(str);
     }
     return [str];
   }
@@ -23725,10 +23735,10 @@ function expand$2(str, isTop) {
     n = parseCommaParts(m.body);
     if (n.length === 1) {
       // x{{a,b}}y ==> x{a}y x{b}y
-      n = expand$2(n[0], false).map(embrace);
+      n = expand$1(n[0], false).map(embrace);
       if (n.length === 1) {
         var post = m.post.length
-          ? expand$2(m.post, false)
+          ? expand$1(m.post, false)
           : [''];
         return post.map(function(p) {
           return m.pre + n[0] + p;
@@ -23743,7 +23753,7 @@ function expand$2(str, isTop) {
   // no need to expand pre, since it is guaranteed to be free of brace-sets
   var pre = m.pre;
   var post = m.post.length
-    ? expand$2(m.post, false)
+    ? expand$1(m.post, false)
     : [''];
 
   var N;
@@ -23787,7 +23797,7 @@ function expand$2(str, isTop) {
       N.push(c);
     }
   } else {
-    N = concatMap(n, function(el) { return expand$2(el, false) });
+    N = concatMap(n, function(el) { return expand$1(el, false) });
   }
 
   for (var j = 0; j < N.length; j++) {
@@ -23810,7 +23820,7 @@ try {
 } catch (er) {}
 
 var GLOBSTAR$1 = minimatch$3.GLOBSTAR = Minimatch$1.GLOBSTAR = {};
-var expand$1 = braceExpansion;
+var expand = braceExpansion;
 
 var plTypes = {
   '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
@@ -24055,7 +24065,7 @@ function braceExpand (pattern, options) {
     return [pattern]
   }
 
-  return expand$1(pattern)
+  return expand(pattern)
 }
 
 // parse a component of the expanded set.
@@ -29778,6 +29788,7 @@ function ssrManifestPlugin(config) {
     return {
         name: 'vite:ssr-manifest',
         generateBundle(_options, bundle) {
+            var _a;
             for (const file in bundle) {
                 const chunk = bundle[file];
                 if (chunk.type === 'chunk') {
@@ -29789,7 +29800,7 @@ function ssrManifestPlugin(config) {
                     const assetFiles = chunkToEmittedAssetsMap.get(chunk);
                     for (const id in chunk.modules) {
                         const normalizedId = normalizePath$4(path$r.relative(config.root, id));
-                        const mappedChunks = ssrManifest[normalizedId] || (ssrManifest[normalizedId] = []);
+                        const mappedChunks = (_a = ssrManifest[normalizedId]) !== null && _a !== void 0 ? _a : (ssrManifest[normalizedId] = []);
                         if (!chunk.isEntry) {
                             mappedChunks.push(base + chunk.fileName);
                         }
@@ -29851,7 +29862,9 @@ function ssrManifestPlugin(config) {
                 }
             }
             this.emitFile({
-                fileName: 'ssr-manifest.json',
+                fileName: typeof config.build.ssrManifest === 'string'
+                    ? config.build.ssrManifest
+                    : 'ssr-manifest.json',
                 type: 'asset',
                 source: JSON.stringify(ssrManifest, null, 2)
             });
@@ -38538,7 +38551,7 @@ function esbuildScanPlugin(config, container, depImports, missing, entries) {
                                 loader,
                                 contents: localContent
                             };
-                            js += `import '${virtualModulePrefix}${path}';\n`;
+                            js += `import ${JSON.stringify(virtualModulePrefix + path)}\n`;
                         }
                         else {
                             js += content + '\n';
@@ -39234,7 +39247,7 @@ function onRollupWarning(warning, warn, config) {
     }
 }
 function resolveExternal(ssrExternals, user) {
-    return ((id, parentId, isResolved) => {
+    return (id, parentId, isResolved) => {
         if (shouldExternalizeForSSR(id, ssrExternals)) {
             return true;
         }
@@ -39249,7 +39262,7 @@ function resolveExternal(ssrExternals, user) {
                 return isExternal(id, user);
             }
         }
-    });
+    };
 }
 function isExternal(id, test) {
     if (typeof test === 'string') {
@@ -39259,10 +39272,10 @@ function isExternal(id, test) {
         return test.test(id);
     }
 }
-function injectSsrFlagToHooks(p) {
-    const { resolveId, load, transform } = p;
+function injectSsrFlagToHooks(plugin) {
+    const { resolveId, load, transform } = plugin;
     return {
-        ...p,
+        ...plugin,
         resolveId: wrapSsrResolveId(resolveId),
         load: wrapSsrLoad(load),
         transform: wrapSsrTransform(transform)
@@ -39278,21 +39291,21 @@ function wrapSsrResolveId(fn) {
 function wrapSsrLoad(fn) {
     if (!fn)
         return;
-    // Receiving options param to be future-proof if Rollup adds it
     return function (id, ...args) {
+        // @ts-expect-error: Receiving options param to be future-proof if Rollup adds it
         return fn.call(this, id, injectSsrFlag(args[0]));
     };
 }
 function wrapSsrTransform(fn) {
     if (!fn)
         return;
-    // Receiving options param to be future-proof if Rollup adds it
     return function (code, importer, ...args) {
+        // @ts-expect-error: Receiving options param to be future-proof if Rollup adds it
         return fn.call(this, code, importer, injectSsrFlag(args[0]));
     };
 }
-function injectSsrFlag(options = {}) {
-    return { ...options, ssr: true };
+function injectSsrFlag(options) {
+    return { ...(options !== null && options !== void 0 ? options : {}), ssr: true };
 }
 
 var build$1 = {
@@ -45036,7 +45049,7 @@ async function getCertificate(cacheDir) {
         return content;
     }
     catch {
-        const content = (await Promise.resolve().then(function () { return require('./dep-6a30742f.js'); })).createCertificate();
+        const content = (await Promise.resolve().then(function () { return require('./dep-8a5027b8.js'); })).createCertificate();
         fs$n.promises
             .mkdir(cacheDir, { recursive: true })
             .then(() => fs$n.promises.writeFile(cachePath, content))
@@ -48221,6 +48234,45 @@ function initAsClient(websocket, address, protocols, options) {
     opts.path = parts[1];
   }
 
+  if (opts.followRedirects) {
+    if (websocket._redirects === 0) {
+      websocket._originalHost = parsedUrl.host;
+
+      const headers = options && options.headers;
+
+      //
+      // Shallow copy the user provided options so that headers can be changed
+      // without mutating the original object.
+      //
+      options = { ...options, headers: {} };
+
+      if (headers) {
+        for (const [key, value] of Object.entries(headers)) {
+          options.headers[key.toLowerCase()] = value;
+        }
+      }
+    } else if (parsedUrl.host !== websocket._originalHost) {
+      //
+      // Match curl 7.77.0 behavior and drop the following headers. These
+      // headers are also dropped when following a redirect to a subdomain.
+      //
+      delete opts.headers.authorization;
+      delete opts.headers.cookie;
+      delete opts.headers.host;
+      opts.auth = undefined;
+    }
+
+    //
+    // Match curl 7.77.0 behavior and make the first `Authorization` header win.
+    // If the `Authorization` header is set, then there is nothing to do as it
+    // will take precedence.
+    //
+    if (opts.auth && !options.headers.authorization) {
+      options.headers.authorization =
+        'Basic ' + Buffer.from(opts.auth).toString('base64');
+    }
+  }
+
   let req = (websocket._req = get(opts));
 
   if (opts.timeout) {
@@ -48786,6 +48838,8 @@ class WebSocketServer extends EventEmitter {
    * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
    *     not to skip UTF-8 validation for text and close messages
    * @param {Function} [options.verifyClient] A hook to reject connections
+   * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
+   *     class to use. It must be the `WebSocket` class or class that extends it
    * @param {Function} [callback] A listener for the `listening` event
    */
   constructor(options, callback) {
@@ -48804,6 +48858,7 @@ class WebSocketServer extends EventEmitter {
       host: null,
       path: null,
       port: null,
+      WebSocket,
       ...options
     };
 
@@ -49093,7 +49148,7 @@ class WebSocketServer extends EventEmitter {
       `Sec-WebSocket-Accept: ${digest}`
     ];
 
-    const ws = new WebSocket(null);
+    const ws = new this.options.WebSocket(null);
 
     if (protocols.size) {
       //
@@ -55902,7 +55957,7 @@ function ssrRewriteStacktrace(stack, moduleGraph) {
         .split('\n')
         .map((line) => {
         return line.replace(/^ {4}at (?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?)\)?/, (input, varName, url, line, column) => {
-            var _a;
+            var _a, _b, _c;
             if (!url)
                 return input;
             const mod = moduleGraph.urlToModuleMap.get(url);
@@ -55919,7 +55974,7 @@ function ssrRewriteStacktrace(stack, moduleGraph) {
             if (!pos.source) {
                 return input;
             }
-            const source = `${pos.source}:${pos.line || 0}:${pos.column || 0}`;
+            const source = `${pos.source}:${(_b = pos.line) !== null && _b !== void 0 ? _b : 0}:${(_c = pos.column) !== null && _c !== void 0 ? _c : 0}`;
             if (!varName || varName === 'eval') {
                 return `    at ${source}`;
             }
@@ -69490,6 +69545,12 @@ async function preview(inlineConfig) {
     };
 }
 
+var preview$1 = {
+	__proto__: null,
+	resolvePreviewOptions: resolvePreviewOptions,
+	preview: preview
+};
+
 function matches(pattern, importee) {
     if (pattern instanceof RegExp) {
         return pattern.test(importee);
@@ -70565,7 +70626,7 @@ async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
     ].filter(Boolean);
 }
 
-var main = {exports: {}};
+var main$1 = {exports: {}};
 
 const fs = fs__default;
 const path = path__default;
@@ -70706,70 +70767,56 @@ const DotenvModule = {
   parse
 };
 
-main.exports.config = DotenvModule.config;
-main.exports.parse = DotenvModule.parse;
-main.exports = DotenvModule;
+main$1.exports.config = DotenvModule.config;
+main$1.exports.parse = DotenvModule.parse;
+main$1.exports = DotenvModule;
 
-var dotenv = main.exports;
+var dotenv = main$1.exports;
 
-function _interpolate (envValue, environment, config) {
-  const matches = envValue.match(/(.?\${*[\w]*(?::-)?[\w]*}*)/g) || [];
+var dotenvExpand = function (config) {
+  // if ignoring process.env, use a blank object
+  var environment = config.ignoreProcessEnv ? {} : process.env;
 
-  return matches.reduce(function (newEnv, match, index) {
-    const parts = /(.?)\${*([\w]*(?::-)?[\w]*)?}*/g.exec(match);
-    if (!parts || parts.length === 0) {
-      return newEnv
-    }
+  var interpolate = function (envValue) {
+    var matches = envValue.match(/(.?\${?(?:[a-zA-Z0-9_]+)?}?)/g) || [];
 
-    const prefix = parts[1];
+    return matches.reduce(function (newEnv, match) {
+      var parts = /(.?)\${?([a-zA-Z0-9_]+)?}?/g.exec(match);
+      var prefix = parts[1];
 
-    let value, replacePart;
+      var value, replacePart;
 
-    if (prefix === '\\') {
-      replacePart = parts[0];
-      value = replacePart.replace('\\$', '$');
-    } else {
-      const keyParts = parts[2].split(':-');
-      const key = keyParts[0];
-      replacePart = parts[0].substring(prefix.length);
-      // process.env value 'wins' over .env file's value
-      value = Object.prototype.hasOwnProperty.call(environment, key)
-        ? environment[key]
-        : (config.parsed[key] || keyParts[1] || '');
-
-      // If the value is found, remove nested expansions.
-      if (keyParts.length > 1 && value) {
-        const replaceNested = matches[index + 1];
-        matches[index + 1] = '';
-
-        newEnv = newEnv.replace(replaceNested, '');
-      }
-      // Resolve recursive interpolations
-      value = _interpolate(value, environment, config);
-    }
+      if (prefix === '\\') {
+        replacePart = parts[0];
+        value = replacePart.replace('\\$', '$');
+      } else {
+        var key = parts[2];
+        replacePart = parts[0].substring(prefix.length);
+        // process.env value 'wins' over .env file's value
+        value = environment.hasOwnProperty(key) ? environment[key] : (config.parsed[key] || '');
 
-    return newEnv.replace(replacePart, value)
-  }, envValue)
-}
+        // Resolve recursive interpolations
+        value = interpolate(value);
+      }
 
-function expand (config) {
-  // if ignoring process.env, use a blank object
-  const environment = config.ignoreProcessEnv ? {} : process.env;
+      return newEnv.replace(replacePart, value)
+    }, envValue)
+  };
 
-  for (const configKey in config.parsed) {
-    const value = Object.prototype.hasOwnProperty.call(environment, configKey) ? environment[configKey] : config.parsed[configKey];
+  for (var configKey in config.parsed) {
+    var value = environment.hasOwnProperty(configKey) ? environment[configKey] : config.parsed[configKey];
 
-    config.parsed[configKey] = _interpolate(value, environment, config);
+    config.parsed[configKey] = interpolate(value);
   }
 
-  for (const processKey in config.parsed) {
+  for (var processKey in config.parsed) {
     environment[processKey] = config.parsed[processKey];
   }
 
   return config
-}
+};
 
-var expand_1 = expand;
+var main = dotenvExpand;
 
 const debug = createDebugger('vite:config');
 /**
@@ -71383,7 +71430,7 @@ function loadEnv(mode, envDir, prefixes = 'VITE_') {
                 debug: ((_a = process.env.DEBUG) === null || _a === void 0 ? void 0 : _a.includes('vite:dotenv')) || undefined
             });
             // let environment variables use each other
-            expand_1({
+            main({
                 parsed,
                 // prevent process.env mutation
                 ignoreProcessEnv: true
@@ -71429,6 +71476,7 @@ exports.mergeConfig = mergeConfig;
 exports.normalizePath = normalizePath$4;
 exports.optimizeDeps = optimizeDeps;
 exports.preview = preview;
+exports.preview$1 = preview$1;
 exports.printHttpServerUrls = printHttpServerUrls;
 exports.resolveConfig = resolveConfig;
 exports.resolveEnvPrefix = resolveEnvPrefix;