@vitest/browser 2.1.4 → 2.1.6

package/dist/client/__vitest_browser__/{tester-CAAquV6P.js → tester-BaiNqOPw.js}

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { a as getConfig, g as getBrowserState, e as executor, b as getWorkerState } from "./utils-CUwLt_eT.js";
+import { a as getConfig, g as getBrowserState, b as resolve, e as executor, c as getWorkerState } from "./utils-Owv5OOOf.js";
 import { globalChannel, client, onCancel, channel } from "@vitest/browser/client";
 import { userEvent, page } from "@vitest/browser/context";
 import { loadDiffConfig, loadSnapshotSerializers, takeCoverageInsideWorker, setupCommonEnv, startCoverageInsideWorker, startTests, collectTests, stopCoverageInsideWorker, SpyModule } from "vitest/browser";
@@ -11313,6 +11313,7 @@ async function setupExpectDom() {
       if (elementOrLocator instanceof Element || elementOrLocator == null) {
         return elementOrLocator;
       }
+      chai.util.flag(this, "_poll.element", true);
       const isNot = chai.util.flag(this, "negate");
       const name = chai.util.flag(this, "_name");
       if (isNot && name === "toBeInTheDocument") {
@@ -11403,7 +11404,8 @@ function setupConsoleLogSpy() {
     trace(...args);
     const content = processLog(args);
     const error2 = new Error("$$Trace");
-    const stack = (error2.stack || "").split("\n").slice(((_a = error2.stack) == null ? void 0 : _a.includes("$$Trace")) ? 2 : 1).join("\n");
+    const processor = ((_a = globalThis.__vitest_worker__) == null ? void 0 : _a.onFilterStackTrace) || ((s) => s || "");
+    const stack = processor(error2.stack || "");
     sendLog("stderr", `${content}
 ${stack}`, true);
   };
@@ -12276,6 +12278,1245 @@ function createModuleMockerInterceptor() {
     }
   });
 }
+var traceMapping_umd = { exports: {} };
+var sourcemapCodec_umd = { exports: {} };
+var hasRequiredSourcemapCodec_umd;
+function requireSourcemapCodec_umd() {
+  if (hasRequiredSourcemapCodec_umd) return sourcemapCodec_umd.exports;
+  hasRequiredSourcemapCodec_umd = 1;
+  (function(module, exports) {
+    (function(global2, factory) {
+      factory(exports);
+    })(commonjsGlobal, function(exports2) {
+      const comma = ",".charCodeAt(0);
+      const semicolon = ";".charCodeAt(0);
+      const chars2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+      const intToChar2 = new Uint8Array(64);
+      const charToInt2 = new Uint8Array(128);
+      for (let i = 0; i < chars2.length; i++) {
+        const c = chars2.charCodeAt(i);
+        intToChar2[i] = c;
+        charToInt2[c] = i;
+      }
+      function decodeInteger(reader, relative) {
+        let value = 0;
+        let shift = 0;
+        let integer = 0;
+        do {
+          const c = reader.next();
+          integer = charToInt2[c];
+          value |= (integer & 31) << shift;
+          shift += 5;
+        } while (integer & 32);
+        const shouldNegate = value & 1;
+        value >>>= 1;
+        if (shouldNegate) {
+          value = -2147483648 | -value;
+        }
+        return relative + value;
+      }
+      function encodeInteger(builder, num, relative) {
+        let delta = num - relative;
+        delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+        do {
+          let clamped = delta & 31;
+          delta >>>= 5;
+          if (delta > 0)
+            clamped |= 32;
+          builder.write(intToChar2[clamped]);
+        } while (delta > 0);
+        return num;
+      }
+      function hasMoreVlq(reader, max) {
+        if (reader.pos >= max)
+          return false;
+        return reader.peek() !== comma;
+      }
+      const bufLength = 1024 * 16;
+      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;
+        }
+      };
+      class StringWriter {
+        constructor() {
+          this.pos = 0;
+          this.out = "";
+          this.buffer = new Uint8Array(bufLength);
+        }
+        write(v) {
+          const { buffer } = this;
+          buffer[this.pos++] = v;
+          if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+          }
+        }
+        flush() {
+          const { buffer, out, pos } = this;
+          return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+        }
+      }
+      class StringReader {
+        constructor(buffer) {
+          this.pos = 0;
+          this.buffer = buffer;
+        }
+        next() {
+          return this.buffer.charCodeAt(this.pos++);
+        }
+        peek() {
+          return this.buffer.charCodeAt(this.pos);
+        }
+        indexOf(char) {
+          const { buffer, pos } = this;
+          const idx = buffer.indexOf(char, pos);
+          return idx === -1 ? buffer.length : idx;
+        }
+      }
+      const EMPTY = [];
+      function decodeOriginalScopes(input) {
+        const { length } = input;
+        const reader = new StringReader(input);
+        const scopes = [];
+        const stack = [];
+        let line = 0;
+        for (; reader.pos < length; reader.pos++) {
+          line = decodeInteger(reader, line);
+          const column = decodeInteger(reader, 0);
+          if (!hasMoreVlq(reader, length)) {
+            const last = stack.pop();
+            last[2] = line;
+            last[3] = column;
+            continue;
+          }
+          const kind = decodeInteger(reader, 0);
+          const fields = decodeInteger(reader, 0);
+          const hasName = fields & 1;
+          const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind];
+          let vars = EMPTY;
+          if (hasMoreVlq(reader, length)) {
+            vars = [];
+            do {
+              const varsIndex = decodeInteger(reader, 0);
+              vars.push(varsIndex);
+            } while (hasMoreVlq(reader, length));
+          }
+          scope.vars = vars;
+          scopes.push(scope);
+          stack.push(scope);
+        }
+        return scopes;
+      }
+      function encodeOriginalScopes(scopes) {
+        const writer = new StringWriter();
+        for (let i = 0; i < scopes.length; ) {
+          i = _encodeOriginalScopes(scopes, i, writer, [0]);
+        }
+        return writer.flush();
+      }
+      function _encodeOriginalScopes(scopes, index, writer, state) {
+        const scope = scopes[index];
+        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
+        if (index > 0)
+          writer.write(comma);
+        state[0] = encodeInteger(writer, startLine, state[0]);
+        encodeInteger(writer, startColumn, 0);
+        encodeInteger(writer, kind, 0);
+        const fields = scope.length === 6 ? 1 : 0;
+        encodeInteger(writer, fields, 0);
+        if (scope.length === 6)
+          encodeInteger(writer, scope[5], 0);
+        for (const v of vars) {
+          encodeInteger(writer, v, 0);
+        }
+        for (index++; index < scopes.length; ) {
+          const next = scopes[index];
+          const { 0: l, 1: c } = next;
+          if (l > endLine || l === endLine && c >= endColumn) {
+            break;
+          }
+          index = _encodeOriginalScopes(scopes, index, writer, state);
+        }
+        writer.write(comma);
+        state[0] = encodeInteger(writer, endLine, state[0]);
+        encodeInteger(writer, endColumn, 0);
+        return index;
+      }
+      function decodeGeneratedRanges(input) {
+        const { length } = input;
+        const reader = new StringReader(input);
+        const ranges = [];
+        const stack = [];
+        let genLine = 0;
+        let definitionSourcesIndex = 0;
+        let definitionScopeIndex = 0;
+        let callsiteSourcesIndex = 0;
+        let callsiteLine = 0;
+        let callsiteColumn = 0;
+        let bindingLine = 0;
+        let bindingColumn = 0;
+        do {
+          const semi = reader.indexOf(";");
+          let genColumn = 0;
+          for (; reader.pos < semi; reader.pos++) {
+            genColumn = decodeInteger(reader, genColumn);
+            if (!hasMoreVlq(reader, semi)) {
+              const last = stack.pop();
+              last[2] = genLine;
+              last[3] = genColumn;
+              continue;
+            }
+            const fields = decodeInteger(reader, 0);
+            const hasDefinition = fields & 1;
+            const hasCallsite = fields & 2;
+            const hasScope = fields & 4;
+            let callsite = null;
+            let bindings = EMPTY;
+            let range;
+            if (hasDefinition) {
+              const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
+              definitionScopeIndex = decodeInteger(reader, definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0);
+              definitionSourcesIndex = defSourcesIndex;
+              range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
+            } else {
+              range = [genLine, genColumn, 0, 0];
+            }
+            range.isScope = !!hasScope;
+            if (hasCallsite) {
+              const prevCsi = callsiteSourcesIndex;
+              const prevLine = callsiteLine;
+              callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
+              const sameSource = prevCsi === callsiteSourcesIndex;
+              callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
+              callsiteColumn = decodeInteger(reader, sameSource && prevLine === callsiteLine ? callsiteColumn : 0);
+              callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+            }
+            range.callsite = callsite;
+            if (hasMoreVlq(reader, semi)) {
+              bindings = [];
+              do {
+                bindingLine = genLine;
+                bindingColumn = genColumn;
+                const expressionsCount = decodeInteger(reader, 0);
+                let expressionRanges;
+                if (expressionsCount < -1) {
+                  expressionRanges = [[decodeInteger(reader, 0)]];
+                  for (let i = -1; i > expressionsCount; i--) {
+                    const prevBl = bindingLine;
+                    bindingLine = decodeInteger(reader, bindingLine);
+                    bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
+                    const expression = decodeInteger(reader, 0);
+                    expressionRanges.push([expression, bindingLine, bindingColumn]);
+                  }
+                } else {
+                  expressionRanges = [[expressionsCount]];
+                }
+                bindings.push(expressionRanges);
+              } while (hasMoreVlq(reader, semi));
+            }
+            range.bindings = bindings;
+            ranges.push(range);
+            stack.push(range);
+          }
+          genLine++;
+          reader.pos = semi + 1;
+        } while (reader.pos < length);
+        return ranges;
+      }
+      function encodeGeneratedRanges(ranges) {
+        if (ranges.length === 0)
+          return "";
+        const writer = new StringWriter();
+        for (let i = 0; i < ranges.length; ) {
+          i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
+        }
+        return writer.flush();
+      }
+      function _encodeGeneratedRanges(ranges, index, writer, state) {
+        const range = ranges[index];
+        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, isScope, callsite, bindings } = range;
+        if (state[0] < startLine) {
+          catchupLine(writer, state[0], startLine);
+          state[0] = startLine;
+          state[1] = 0;
+        } else if (index > 0) {
+          writer.write(comma);
+        }
+        state[1] = encodeInteger(writer, range[1], state[1]);
+        const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);
+        encodeInteger(writer, fields, 0);
+        if (range.length === 6) {
+          const { 4: sourcesIndex, 5: scopesIndex } = range;
+          if (sourcesIndex !== state[2]) {
+            state[3] = 0;
+          }
+          state[2] = encodeInteger(writer, sourcesIndex, state[2]);
+          state[3] = encodeInteger(writer, scopesIndex, state[3]);
+        }
+        if (callsite) {
+          const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
+          if (sourcesIndex !== state[4]) {
+            state[5] = 0;
+            state[6] = 0;
+          } else if (callLine !== state[5]) {
+            state[6] = 0;
+          }
+          state[4] = encodeInteger(writer, sourcesIndex, state[4]);
+          state[5] = encodeInteger(writer, callLine, state[5]);
+          state[6] = encodeInteger(writer, callColumn, state[6]);
+        }
+        if (bindings) {
+          for (const binding of bindings) {
+            if (binding.length > 1)
+              encodeInteger(writer, -binding.length, 0);
+            const expression = binding[0][0];
+            encodeInteger(writer, expression, 0);
+            let bindingStartLine = startLine;
+            let bindingStartColumn = startColumn;
+            for (let i = 1; i < binding.length; i++) {
+              const expRange = binding[i];
+              bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);
+              bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);
+              encodeInteger(writer, expRange[0], 0);
+            }
+          }
+        }
+        for (index++; index < ranges.length; ) {
+          const next = ranges[index];
+          const { 0: l, 1: c } = next;
+          if (l > endLine || l === endLine && c >= endColumn) {
+            break;
+          }
+          index = _encodeGeneratedRanges(ranges, index, writer, state);
+        }
+        if (state[0] < endLine) {
+          catchupLine(writer, state[0], endLine);
+          state[0] = endLine;
+          state[1] = 0;
+        } else {
+          writer.write(comma);
+        }
+        state[1] = encodeInteger(writer, endColumn, state[1]);
+        return index;
+      }
+      function catchupLine(writer, lastLine, line) {
+        do {
+          writer.write(semicolon);
+        } while (++lastLine < line);
+      }
+      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);
+      }
+      function sortComparator(a, b) {
+        return a[0] - b[0];
+      }
+      function encode(decoded) {
+        const writer = new StringWriter();
+        let sourcesIndex = 0;
+        let sourceLine = 0;
+        let sourceColumn = 0;
+        let namesIndex = 0;
+        for (let i = 0; i < decoded.length; i++) {
+          const line = decoded[i];
+          if (i > 0)
+            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);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
+            if (segment.length === 1)
+              continue;
+            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(writer, segment[4], namesIndex);
+          }
+        }
+        return writer.flush();
+      }
+      exports2.decode = decode;
+      exports2.decodeGeneratedRanges = decodeGeneratedRanges;
+      exports2.decodeOriginalScopes = decodeOriginalScopes;
+      exports2.encode = encode;
+      exports2.encodeGeneratedRanges = encodeGeneratedRanges;
+      exports2.encodeOriginalScopes = encodeOriginalScopes;
+      Object.defineProperty(exports2, "__esModule", { value: true });
+    });
+  })(sourcemapCodec_umd, sourcemapCodec_umd.exports);
+  return sourcemapCodec_umd.exports;
+}
+var resolveUri_umd = { exports: {} };
+var hasRequiredResolveUri_umd;
+function requireResolveUri_umd() {
+  if (hasRequiredResolveUri_umd) return resolveUri_umd.exports;
+  hasRequiredResolveUri_umd = 1;
+  (function(module, exports) {
+    (function(global2, factory) {
+      module.exports = factory();
+    })(commonjsGlobal, function() {
+      const schemeRegex = /^[\w+.-]+:\/\//;
+      const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+      const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+      var UrlType2;
+      (function(UrlType3) {
+        UrlType3[UrlType3["Empty"] = 1] = "Empty";
+        UrlType3[UrlType3["Hash"] = 2] = "Hash";
+        UrlType3[UrlType3["Query"] = 3] = "Query";
+        UrlType3[UrlType3["RelativePath"] = 4] = "RelativePath";
+        UrlType3[UrlType3["AbsolutePath"] = 5] = "AbsolutePath";
+        UrlType3[UrlType3["SchemeRelative"] = 6] = "SchemeRelative";
+        UrlType3[UrlType3["Absolute"] = 7] = "Absolute";
+      })(UrlType2 || (UrlType2 = {}));
+      function isAbsoluteUrl(input) {
+        return schemeRegex.test(input);
+      }
+      function isSchemeRelativeUrl(input) {
+        return input.startsWith("//");
+      }
+      function isAbsolutePath(input) {
+        return input.startsWith("/");
+      }
+      function isFileUrl(input) {
+        return input.startsWith("file:");
+      }
+      function isRelative(input) {
+        return /^[.?#]/.test(input);
+      }
+      function parseAbsoluteUrl(input) {
+        const match = urlRegex.exec(input);
+        return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+      }
+      function parseFileUrl(input) {
+        const match = fileRegex.exec(input);
+        const path = match[2];
+        return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+      }
+      function makeUrl(scheme, user, host, port, path, query, hash) {
+        return {
+          scheme,
+          user,
+          host,
+          port,
+          path,
+          query,
+          hash,
+          type: UrlType2.Absolute
+        };
+      }
+      function parseUrl(input) {
+        if (isSchemeRelativeUrl(input)) {
+          const url3 = parseAbsoluteUrl("http:" + input);
+          url3.scheme = "";
+          url3.type = UrlType2.SchemeRelative;
+          return url3;
+        }
+        if (isAbsolutePath(input)) {
+          const url3 = parseAbsoluteUrl("http://foo.com" + input);
+          url3.scheme = "";
+          url3.host = "";
+          url3.type = UrlType2.AbsolutePath;
+          return url3;
+        }
+        if (isFileUrl(input))
+          return parseFileUrl(input);
+        if (isAbsoluteUrl(input))
+          return parseAbsoluteUrl(input);
+        const url2 = parseAbsoluteUrl("http://foo.com/" + input);
+        url2.scheme = "";
+        url2.host = "";
+        url2.type = input ? input.startsWith("?") ? UrlType2.Query : input.startsWith("#") ? UrlType2.Hash : UrlType2.RelativePath : UrlType2.Empty;
+        return url2;
+      }
+      function stripPathFilename(path) {
+        if (path.endsWith("/.."))
+          return path;
+        const index = path.lastIndexOf("/");
+        return path.slice(0, index + 1);
+      }
+      function mergePaths(url2, base) {
+        normalizePath(base, base.type);
+        if (url2.path === "/") {
+          url2.path = base.path;
+        } else {
+          url2.path = stripPathFilename(base.path) + url2.path;
+        }
+      }
+      function normalizePath(url2, type) {
+        const rel = type <= UrlType2.RelativePath;
+        const pieces = url2.path.split("/");
+        let pointer = 1;
+        let positive = 0;
+        let addTrailingSlash = false;
+        for (let i = 1; i < pieces.length; i++) {
+          const piece = pieces[i];
+          if (!piece) {
+            addTrailingSlash = true;
+            continue;
+          }
+          addTrailingSlash = false;
+          if (piece === ".")
+            continue;
+          if (piece === "..") {
+            if (positive) {
+              addTrailingSlash = true;
+              positive--;
+              pointer--;
+            } else if (rel) {
+              pieces[pointer++] = piece;
+            }
+            continue;
+          }
+          pieces[pointer++] = piece;
+          positive++;
+        }
+        let path = "";
+        for (let i = 1; i < pointer; i++) {
+          path += "/" + pieces[i];
+        }
+        if (!path || addTrailingSlash && !path.endsWith("/..")) {
+          path += "/";
+        }
+        url2.path = path;
+      }
+      function resolve2(input, base) {
+        if (!input && !base)
+          return "";
+        const url2 = parseUrl(input);
+        let inputType = url2.type;
+        if (base && inputType !== UrlType2.Absolute) {
+          const baseUrl = parseUrl(base);
+          const baseType = baseUrl.type;
+          switch (inputType) {
+            case UrlType2.Empty:
+              url2.hash = baseUrl.hash;
+            case UrlType2.Hash:
+              url2.query = baseUrl.query;
+            case UrlType2.Query:
+            case UrlType2.RelativePath:
+              mergePaths(url2, baseUrl);
+            case UrlType2.AbsolutePath:
+              url2.user = baseUrl.user;
+              url2.host = baseUrl.host;
+              url2.port = baseUrl.port;
+            case UrlType2.SchemeRelative:
+              url2.scheme = baseUrl.scheme;
+          }
+          if (baseType > inputType)
+            inputType = baseType;
+        }
+        normalizePath(url2, inputType);
+        const queryHash = url2.query + url2.hash;
+        switch (inputType) {
+          case UrlType2.Hash:
+          case UrlType2.Query:
+            return queryHash;
+          case UrlType2.RelativePath: {
+            const path = url2.path.slice(1);
+            if (!path)
+              return queryHash || ".";
+            if (isRelative(base || input) && !isRelative(path)) {
+              return "./" + path + queryHash;
+            }
+            return path + queryHash;
+          }
+          case UrlType2.AbsolutePath:
+            return url2.path + queryHash;
+          default:
+            return url2.scheme + "//" + url2.user + url2.host + url2.port + url2.path + queryHash;
+        }
+      }
+      return resolve2;
+    });
+  })(resolveUri_umd);
+  return resolveUri_umd.exports;
+}
+(function(module, exports) {
+  (function(global2, factory) {
+    factory(exports, requireSourcemapCodec_umd(), requireResolveUri_umd());
+  })(commonjsGlobal, function(exports2, sourcemapCodec, resolveUri) {
+    function resolve2(input, base) {
+      if (base && !base.endsWith("/"))
+        base += "/";
+      return resolveUri(input, base);
+    }
+    function stripFilename(path) {
+      if (!path)
+        return "";
+      const index = path.lastIndexOf("/");
+      return path.slice(0, index + 1);
+    }
+    const COLUMN = 0;
+    const SOURCES_INDEX = 1;
+    const SOURCE_LINE = 2;
+    const SOURCE_COLUMN = 3;
+    const NAMES_INDEX = 4;
+    const REV_GENERATED_LINE = 1;
+    const REV_GENERATED_COLUMN = 2;
+    function maybeSort(mappings, owned) {
+      const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+      if (unsortedIndex === mappings.length)
+        return mappings;
+      if (!owned)
+        mappings = mappings.slice();
+      for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+        mappings[i] = sortSegments(mappings[i], owned);
+      }
+      return mappings;
+    }
+    function nextUnsortedSegmentLine(mappings, start) {
+      for (let i = start; i < mappings.length; i++) {
+        if (!isSorted(mappings[i]))
+          return i;
+      }
+      return mappings.length;
+    }
+    function isSorted(line) {
+      for (let j = 1; j < line.length; j++) {
+        if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function sortSegments(line, owned) {
+      if (!owned)
+        line = line.slice();
+      return line.sort(sortComparator);
+    }
+    function sortComparator(a, b) {
+      return a[COLUMN] - b[COLUMN];
+    }
+    let found = false;
+    function binarySearch(haystack, needle, low, high) {
+      while (low <= high) {
+        const mid = low + (high - low >> 1);
+        const cmp = haystack[mid][COLUMN] - needle;
+        if (cmp === 0) {
+          found = true;
+          return mid;
+        }
+        if (cmp < 0) {
+          low = mid + 1;
+        } else {
+          high = mid - 1;
+        }
+      }
+      found = false;
+      return low - 1;
+    }
+    function upperBound(haystack, needle, index) {
+      for (let i = index + 1; i < haystack.length; index = i++) {
+        if (haystack[i][COLUMN] !== needle)
+          break;
+      }
+      return index;
+    }
+    function lowerBound(haystack, needle, index) {
+      for (let i = index - 1; i >= 0; index = i--) {
+        if (haystack[i][COLUMN] !== needle)
+          break;
+      }
+      return index;
+    }
+    function memoizedState() {
+      return {
+        lastKey: -1,
+        lastNeedle: -1,
+        lastIndex: -1
+      };
+    }
+    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) {
+          found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+          return lastIndex;
+        }
+        if (needle >= lastNeedle) {
+          low = lastIndex === -1 ? 0 : lastIndex;
+        } else {
+          high = lastIndex;
+        }
+      }
+      state.lastKey = key;
+      state.lastNeedle = needle;
+      return state.lastIndex = binarySearch(haystack, needle, low, high);
+    }
+    function buildBySources(decoded, memos) {
+      const sources = memos.map(buildNullArray);
+      for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        for (let j = 0; j < line.length; j++) {
+          const seg = line[j];
+          if (seg.length === 1)
+            continue;
+          const sourceIndex2 = seg[SOURCES_INDEX];
+          const sourceLine = seg[SOURCE_LINE];
+          const sourceColumn = seg[SOURCE_COLUMN];
+          const originalSource = sources[sourceIndex2];
+          const originalLine = originalSource[sourceLine] || (originalSource[sourceLine] = []);
+          const memo = memos[sourceIndex2];
+          let index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
+          memo.lastIndex = ++index;
+          insert(originalLine, index, [sourceColumn, i, seg[COLUMN]]);
+        }
+      }
+      return sources;
+    }
+    function insert(array, index, value) {
+      for (let i = array.length; i > index; i--) {
+        array[i] = array[i - 1];
+      }
+      array[index] = value;
+    }
+    function buildNullArray() {
+      return { __proto__: null };
+    }
+    const AnyMap = function(map, mapUrl) {
+      const parsed = parse(map);
+      if (!("sections" in parsed)) {
+        return new TraceMap2(parsed, mapUrl);
+      }
+      const mappings = [];
+      const sources = [];
+      const sourcesContent = [];
+      const names = [];
+      const ignoreList = [];
+      recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, ignoreList, 0, 0, Infinity, Infinity);
+      const joined = {
+        version: 3,
+        file: parsed.file,
+        names,
+        sources,
+        sourcesContent,
+        mappings,
+        ignoreList
+      };
+      return presortedDecodedMap(joined);
+    };
+    function parse(map) {
+      return typeof map === "string" ? JSON.parse(map) : map;
+    }
+    function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+      const { sections } = input;
+      for (let i = 0; i < sections.length; i++) {
+        const { map, offset } = sections[i];
+        let sl = stopLine;
+        let sc = stopColumn;
+        if (i + 1 < sections.length) {
+          const nextOffset = sections[i + 1].offset;
+          sl = Math.min(stopLine, lineOffset + nextOffset.line);
+          if (sl === stopLine) {
+            sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+          } else if (sl < stopLine) {
+            sc = columnOffset + nextOffset.column;
+          }
+        }
+        addSection(map, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
+      }
+    }
+    function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+      const parsed = parse(input);
+      if ("sections" in parsed)
+        return recurse(...arguments);
+      const map = new TraceMap2(parsed, mapUrl);
+      const sourcesOffset = sources.length;
+      const namesOffset = names.length;
+      const decoded = decodedMappings(map);
+      const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
+      append(sources, resolvedSources);
+      append(names, map.names);
+      if (contents)
+        append(sourcesContent, contents);
+      else
+        for (let i = 0; i < resolvedSources.length; i++)
+          sourcesContent.push(null);
+      if (ignores)
+        for (let i = 0; i < ignores.length; i++)
+          ignoreList.push(ignores[i] + sourcesOffset);
+      for (let i = 0; i < decoded.length; i++) {
+        const lineI = lineOffset + i;
+        if (lineI > stopLine)
+          return;
+        const out = getLine(mappings, lineI);
+        const cOffset = i === 0 ? columnOffset : 0;
+        const line = decoded[i];
+        for (let j = 0; j < line.length; j++) {
+          const seg = line[j];
+          const column = cOffset + seg[COLUMN];
+          if (lineI === stopLine && column >= stopColumn)
+            return;
+          if (seg.length === 1) {
+            out.push([column]);
+            continue;
+          }
+          const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
+          const sourceLine = seg[SOURCE_LINE];
+          const sourceColumn = seg[SOURCE_COLUMN];
+          out.push(seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]);
+        }
+      }
+    }
+    function append(arr, other) {
+      for (let i = 0; i < other.length; i++)
+        arr.push(other[i]);
+    }
+    function getLine(arr, index) {
+      for (let i = arr.length; i <= index; i++)
+        arr[i] = [];
+      return arr[index];
+    }
+    const LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+    const COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+    const LEAST_UPPER_BOUND = -1;
+    const GREATEST_LOWER_BOUND = 1;
+    class TraceMap2 {
+      constructor(map, mapUrl) {
+        const isString = typeof map === "string";
+        if (!isString && map._decodedMemo)
+          return map;
+        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;
+        this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+        const from = resolve2(sourceRoot || "", stripFilename(mapUrl));
+        this.resolvedSources = sources.map((s) => resolve2(s || "", from));
+        const { mappings } = parsed;
+        if (typeof mappings === "string") {
+          this._encoded = mappings;
+          this._decoded = void 0;
+        } else {
+          this._encoded = void 0;
+          this._decoded = maybeSort(mappings, isString);
+        }
+        this._decodedMemo = memoizedState();
+        this._bySources = void 0;
+        this._bySourceMemos = void 0;
+      }
+    }
+    function cast(map) {
+      return map;
+    }
+    function encodedMappings(map) {
+      var _a;
+      var _b;
+      return (_a = (_b = cast(map))._encoded) !== null && _a !== void 0 ? _a : _b._encoded = sourcemapCodec.encode(cast(map)._decoded);
+    }
+    function decodedMappings(map) {
+      var _a;
+      return (_a = cast(map))._decoded || (_a._decoded = sourcemapCodec.decode(cast(map)._encoded));
+    }
+    function traceSegment(map, line, column) {
+      const decoded = decodedMappings(map);
+      if (line >= decoded.length)
+        return null;
+      const segments = decoded[line];
+      const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+      return index === -1 ? null : segments[index];
+    }
+    function originalPositionFor2(map, needle) {
+      let { line, column, bias } = needle;
+      line--;
+      if (line < 0)
+        throw new Error(LINE_GTR_ZERO);
+      if (column < 0)
+        throw new Error(COL_GTR_EQ_ZERO);
+      const decoded = decodedMappings(map);
+      if (line >= decoded.length)
+        return OMapping(null, null, null, null);
+      const segments = decoded[line];
+      const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+      if (index === -1)
+        return OMapping(null, null, null, null);
+      const segment = segments[index];
+      if (segment.length === 1)
+        return OMapping(null, null, null, null);
+      const { names, resolvedSources } = map;
+      return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+    }
+    function generatedPositionFor(map, needle) {
+      const { source: source2, line, column, bias } = needle;
+      return generatedPosition(map, source2, line, column, bias || GREATEST_LOWER_BOUND, false);
+    }
+    function allGeneratedPositionsFor(map, needle) {
+      const { source: source2, line, column, bias } = needle;
+      return generatedPosition(map, source2, line, column, bias || LEAST_UPPER_BOUND, true);
+    }
+    function eachMapping(map, cb) {
+      const decoded = decodedMappings(map);
+      const { names, resolvedSources } = map;
+      for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        for (let j = 0; j < line.length; j++) {
+          const seg = line[j];
+          const generatedLine = i + 1;
+          const generatedColumn = seg[0];
+          let source2 = null;
+          let originalLine = null;
+          let originalColumn = null;
+          let name = null;
+          if (seg.length !== 1) {
+            source2 = resolvedSources[seg[1]];
+            originalLine = seg[2] + 1;
+            originalColumn = seg[3];
+          }
+          if (seg.length === 5)
+            name = names[seg[4]];
+          cb({
+            generatedLine,
+            generatedColumn,
+            source: source2,
+            originalLine,
+            originalColumn,
+            name
+          });
+        }
+      }
+    }
+    function sourceIndex(map, source2) {
+      const { sources, resolvedSources } = map;
+      let index = sources.indexOf(source2);
+      if (index === -1)
+        index = resolvedSources.indexOf(source2);
+      return index;
+    }
+    function sourceContentFor(map, source2) {
+      const { sourcesContent } = map;
+      if (sourcesContent == null)
+        return null;
+      const index = sourceIndex(map, source2);
+      return index === -1 ? null : sourcesContent[index];
+    }
+    function isIgnored(map, source2) {
+      const { ignoreList } = map;
+      if (ignoreList == null)
+        return false;
+      const index = sourceIndex(map, source2);
+      return index === -1 ? false : ignoreList.includes(index);
+    }
+    function presortedDecodedMap(map, mapUrl) {
+      const tracer = new TraceMap2(clone(map, []), mapUrl);
+      cast(tracer)._decoded = map.mappings;
+      return tracer;
+    }
+    function decodedMap(map) {
+      return clone(map, decodedMappings(map));
+    }
+    function encodedMap(map) {
+      return clone(map, encodedMappings(map));
+    }
+    function clone(map, mappings) {
+      return {
+        version: map.version,
+        file: map.file,
+        names: map.names,
+        sourceRoot: map.sourceRoot,
+        sources: map.sources,
+        sourcesContent: map.sourcesContent,
+        mappings,
+        ignoreList: map.ignoreList || map.x_google_ignoreList
+      };
+    }
+    function OMapping(source2, line, column, name) {
+      return { source: source2, line, column, name };
+    }
+    function GMapping(line, column) {
+      return { line, column };
+    }
+    function traceSegmentInternal(segments, memo, line, column, bias) {
+      let index = memoizedBinarySearch(segments, column, memo, line);
+      if (found) {
+        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+      } else if (bias === LEAST_UPPER_BOUND)
+        index++;
+      if (index === -1 || index === segments.length)
+        return -1;
+      return index;
+    }
+    function sliceGeneratedPositions(segments, memo, line, column, bias) {
+      let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
+      if (!found && bias === LEAST_UPPER_BOUND)
+        min++;
+      if (min === -1 || min === segments.length)
+        return [];
+      const matchedColumn = found ? column : segments[min][COLUMN];
+      if (!found)
+        min = lowerBound(segments, matchedColumn, min);
+      const max = upperBound(segments, matchedColumn, min);
+      const result = [];
+      for (; min <= max; min++) {
+        const segment = segments[min];
+        result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
+      }
+      return result;
+    }
+    function generatedPosition(map, source2, line, column, bias, all) {
+      var _a;
+      line--;
+      if (line < 0)
+        throw new Error(LINE_GTR_ZERO);
+      if (column < 0)
+        throw new Error(COL_GTR_EQ_ZERO);
+      const { sources, resolvedSources } = map;
+      let sourceIndex2 = sources.indexOf(source2);
+      if (sourceIndex2 === -1)
+        sourceIndex2 = resolvedSources.indexOf(source2);
+      if (sourceIndex2 === -1)
+        return all ? [] : GMapping(null, null);
+      const generated = (_a = cast(map))._bySources || (_a._bySources = buildBySources(decodedMappings(map), cast(map)._bySourceMemos = sources.map(memoizedState)));
+      const segments = generated[sourceIndex2][line];
+      if (segments == null)
+        return all ? [] : GMapping(null, null);
+      const memo = cast(map)._bySourceMemos[sourceIndex2];
+      if (all)
+        return sliceGeneratedPositions(segments, memo, line, column, bias);
+      const index = traceSegmentInternal(segments, memo, line, column, bias);
+      if (index === -1)
+        return GMapping(null, null);
+      const segment = segments[index];
+      return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+    }
+    exports2.AnyMap = AnyMap;
+    exports2.GREATEST_LOWER_BOUND = GREATEST_LOWER_BOUND;
+    exports2.LEAST_UPPER_BOUND = LEAST_UPPER_BOUND;
+    exports2.TraceMap = TraceMap2;
+    exports2.allGeneratedPositionsFor = allGeneratedPositionsFor;
+    exports2.decodedMap = decodedMap;
+    exports2.decodedMappings = decodedMappings;
+    exports2.eachMapping = eachMapping;
+    exports2.encodedMap = encodedMap;
+    exports2.encodedMappings = encodedMappings;
+    exports2.generatedPositionFor = generatedPositionFor;
+    exports2.isIgnored = isIgnored;
+    exports2.originalPositionFor = originalPositionFor2;
+    exports2.presortedDecodedMap = presortedDecodedMap;
+    exports2.sourceContentFor = sourceContentFor;
+    exports2.traceSegment = traceSegment;
+  });
+})(traceMapping_umd, traceMapping_umd.exports);
+var traceMapping_umdExports = traceMapping_umd.exports;
+function notNullish(v) {
+  return v != null;
+}
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+const stackIgnorePatterns = [
+  "node:internal",
+  /\/packages\/\w+\/dist\//,
+  /\/@vitest\/\w+\/dist\//,
+  "/vitest/dist/",
+  "/vitest/src/",
+  "/vite-node/dist/",
+  "/vite-node/src/",
+  "/node_modules/chai/",
+  "/node_modules/tinypool/",
+  "/node_modules/tinyspy/",
+  // browser related deps
+  "/deps/chunk-",
+  "/deps/@vitest",
+  "/deps/loupe",
+  "/deps/chai",
+  /node:\w+/,
+  /__vitest_test__/,
+  /__vitest_browser__/,
+  /\/deps\/vitest_/
+];
+function extractLocation(urlLike) {
+  if (!urlLike.includes(":")) {
+    return [urlLike];
+  }
+  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+  const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
+  if (!parts) {
+    return [urlLike];
+  }
+  let url2 = parts[1];
+  if (url2.startsWith("async ")) {
+    url2 = url2.slice(6);
+  }
+  if (url2.startsWith("http:") || url2.startsWith("https:")) {
+    const urlObj = new URL(url2);
+    url2 = urlObj.pathname;
+  }
+  if (url2.startsWith("/@fs/")) {
+    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url2);
+    url2 = url2.slice(isWindows ? 5 : 4);
+  }
+  return [url2, parts[2] || void 0, parts[3] || void 0];
+}
+function parseSingleFFOrSafariStack(raw) {
+  let line = raw.trim();
+  if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
+    return null;
+  }
+  if (line.includes(" > eval")) {
+    line = line.replace(
+      / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,
+      ":$1"
+    );
+  }
+  if (!line.includes("@") && !line.includes(":")) {
+    return null;
+  }
+  const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(@)/;
+  const matches2 = line.match(functionNameRegex);
+  const functionName = matches2 && matches2[1] ? matches2[1] : void 0;
+  const [url2, lineNumber, columnNumber] = extractLocation(
+    line.replace(functionNameRegex, "")
+  );
+  if (!url2 || !lineNumber || !columnNumber) {
+    return null;
+  }
+  return {
+    file: url2,
+    method: functionName || "",
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+function parseSingleV8Stack(raw) {
+  let line = raw.trim();
+  if (!CHROME_IE_STACK_REGEXP.test(line)) {
+    return null;
+  }
+  if (line.includes("(eval ")) {
+    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  }
+  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+  const location2 = sanitizedLine.match(/ (\(.+\)$)/);
+  sanitizedLine = location2 ? sanitizedLine.replace(location2[0], "") : sanitizedLine;
+  const [url2, lineNumber, columnNumber] = extractLocation(
+    location2 ? location2[1] : sanitizedLine
+  );
+  let method = location2 && sanitizedLine || "";
+  let file = url2 && ["eval", "<anonymous>"].includes(url2) ? void 0 : url2;
+  if (!file || !lineNumber || !columnNumber) {
+    return null;
+  }
+  if (method.startsWith("async ")) {
+    method = method.slice(6);
+  }
+  if (file.startsWith("file://")) {
+    file = file.slice(7);
+  }
+  file = resolve(file);
+  if (method) {
+    method = method.replace(/__vite_ssr_import_\d+__\./g, "");
+  }
+  return {
+    method,
+    file,
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+function createStackString(stacks) {
+  return stacks.map((stack) => {
+    const line = `${stack.file}:${stack.line}:${stack.column}`;
+    if (stack.method) {
+      return `    at ${stack.method}(${line})`;
+    }
+    return `    at ${line}`;
+  }).join("\n");
+}
+function parseStacktrace(stack, options = {}) {
+  const { ignoreStackEntries = stackIgnorePatterns } = options;
+  let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+  if (ignoreStackEntries.length) {
+    stacks = stacks.filter(
+      (stack2) => !ignoreStackEntries.some((p) => stack2.file.match(p))
+    );
+  }
+  return stacks.map((stack2) => {
+    var _a;
+    if (options.getFileName) {
+      stack2.file = options.getFileName(stack2.file);
+    }
+    const map = (_a = options.getSourceMap) == null ? void 0 : _a.call(options, stack2.file);
+    if (!map || typeof map !== "object" || !map.version) {
+      return stack2;
+    }
+    const traceMap = new traceMapping_umdExports.TraceMap(map);
+    const { line, column } = traceMapping_umdExports.originalPositionFor(traceMap, stack2);
+    if (line != null && column != null) {
+      return { ...stack2, line, column };
+    }
+    return stack2;
+  });
+}
+function parseFFOrSafariStackTrace(stack) {
+  return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+}
+function parseV8Stacktrace(stack) {
+  return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
+}
 class VitestBrowserSnapshotEnvironment {
   constructor() {
     __publicField(this, "sourceMaps", /* @__PURE__ */ new Map());
@@ -12450,6 +13691,14 @@ async function initiateRunner(state, mocker, config) {
   ]);
   runner.config.diffOptions = diffOptions;
   cachedRunner = runner;
+  getWorkerState().onFilterStackTrace = (stack) => {
+    const stacks = parseStacktrace(stack, {
+      getSourceMap(file) {
+        return runner.sourceMapCache.get(file);
+      }
+    });
+    return createStackString(stacks);
+  };
   return runner;
 }
 async function updateFilesLocations(files, sourceMaps) {