updated node_modules

1 files changed, 202 insertions, 174 deletions

diff --git a/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs b/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
index d3c1a7ac..8238e0ae 100644
--- a/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+++ b/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
@@ -167,8 +167,9 @@ function buildBySources(decoded, memos) {
             // segment should go. Either way, we want to insert after that. And there may be multiple
             // generated segments associated with an original location, so there may need to move several
             // indexes before we find where we need to insert.
-            const index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
-            insert(originalLine, (memo.lastIndex = index + 1), [sourceColumn, i, seg[COLUMN]]);
+            let index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
+            memo.lastIndex = ++index;
+            insert(originalLine, index, [sourceColumn, i, seg[COLUMN]]);
         }
     }
     return sources;
@@ -189,14 +190,16 @@ function buildNullArray() {
 }
 
 const AnyMap = function (map, mapUrl) {
-    const parsed = typeof map === 'string' ? JSON.parse(map) : map;
-    if (!('sections' in parsed))
+    const parsed = parse(map);
+    if (!('sections' in parsed)) {
         return new TraceMap(parsed, mapUrl);
+    }
     const mappings = [];
     const sources = [];
     const sourcesContent = [];
     const names = [];
-    recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity);
+    const ignoreList = [];
+    recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, ignoreList, 0, 0, Infinity, Infinity);
     const joined = {
         version: 3,
         file: parsed.file,
@@ -204,10 +207,14 @@ const AnyMap = function (map, mapUrl) {
         sources,
         sourcesContent,
         mappings,
+        ignoreList,
     };
     return presortedDecodedMap(joined);
 };
-function recurse(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
+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];
@@ -223,17 +230,18 @@ function recurse(input, mapUrl, mappings, sources, sourcesContent, names, lineOf
                 sc = columnOffset + nextOffset.column;
             }
         }
-        addSection(map, mapUrl, mappings, sources, sourcesContent, names, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
+        addSection(map, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
     }
 }
-function addSection(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
-    if ('sections' in input)
+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 TraceMap(input, mapUrl);
+    const map = new TraceMap(parsed, mapUrl);
     const sourcesOffset = sources.length;
     const namesOffset = names.length;
     const decoded = decodedMappings(map);
-    const { resolvedSources, sourcesContent: contents } = map;
+    const { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
     append(sources, resolvedSources);
     append(names, map.names);
     if (contents)
@@ -241,6 +249,9 @@ function addSection(input, mapUrl, mappings, sources, sourcesContent, names, lin
     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;
         // We can only add so many lines before we step into the range that the next section's map
@@ -290,208 +301,198 @@ 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 TraceMap {
+    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 || undefined;
+        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
+        this.resolvedSources = sources.map((s) => resolve(s || '', from));
+        const { mappings } = parsed;
+        if (typeof mappings === 'string') {
+            this._encoded = mappings;
+            this._decoded = undefined;
+        }
+        else {
+            this._encoded = undefined;
+            this._decoded = maybeSort(mappings, isString);
+        }
+        this._decodedMemo = memoizedState();
+        this._bySources = undefined;
+        this._bySourceMemos = undefined;
+    }
+}
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+ * with public access modifiers.
+ */
+function cast(map) {
+    return map;
+}
 /**
  * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
  */
-let encodedMappings;
+function encodedMappings(map) {
+    var _a;
+    var _b;
+    return ((_a = (_b = cast(map))._encoded) !== null && _a !== void 0 ? _a : (_b._encoded = encode(cast(map)._decoded)));
+}
 /**
  * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
  */
-let decodedMappings;
+function decodedMappings(map) {
+    var _a;
+    return ((_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded)));
+}
 /**
  * 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;
+function traceSegment(map, line, column) {
+    const decoded = decodedMappings(map);
+    // 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 = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+    return index === -1 ? null : segments[index];
+}
 /**
  * A higher-level API to find the source/line/column associated with a generated line/column
  * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
  * `source-map` library.
  */
-let originalPositionFor;
+function originalPositionFor(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);
+    // 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 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);
+}
 /**
  * Finds the generated line/column position of the provided source/line/column source position.
  */
-let generatedPositionFor;
+function generatedPositionFor(map, needle) {
+    const { source, line, column, bias } = needle;
+    return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+}
 /**
  * Finds all generated line/column positions of the provided source/line/column source position.
  */
-let allGeneratedPositionsFor;
+function allGeneratedPositionsFor(map, needle) {
+    const { source, line, column, bias } = needle;
+    // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
+    return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
+}
 /**
  * Iterates each mapping in generated position order.
  */
-let eachMapping;
+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 source = null;
+            let originalLine = null;
+            let originalColumn = null;
+            let name = null;
+            if (seg.length !== 1) {
+                source = resolvedSources[seg[1]];
+                originalLine = seg[2] + 1;
+                originalColumn = seg[3];
+            }
+            if (seg.length === 5)
+                name = names[seg[4]];
+            cb({
+                generatedLine,
+                generatedColumn,
+                source,
+                originalLine,
+                originalColumn,
+                name,
+            });
+        }
+    }
+}
+function sourceIndex(map, source) {
+    const { sources, resolvedSources } = map;
+    let index = sources.indexOf(source);
+    if (index === -1)
+        index = resolvedSources.indexOf(source);
+    return index;
+}
 /**
  * Retrieves the source content for a particular source, if its found. Returns null if not.
  */
-let sourceContentFor;
+function sourceContentFor(map, source) {
+    const { sourcesContent } = map;
+    if (sourcesContent == null)
+        return null;
+    const index = sourceIndex(map, source);
+    return index === -1 ? null : sourcesContent[index];
+}
+/**
+ * Determines if the source is marked to ignore by the source map.
+ */
+function isIgnored(map, source) {
+    const { ignoreList } = map;
+    if (ignoreList == null)
+        return false;
+    const index = sourceIndex(map, source);
+    return index === -1 ? false : ignoreList.includes(index);
+}
 /**
  * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
  * maps.
  */
-let presortedDecodedMap;
+function presortedDecodedMap(map, mapUrl) {
+    const tracer = new TraceMap(clone(map, []), mapUrl);
+    cast(tracer)._decoded = map.mappings;
+    return tracer;
+}
 /**
  * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
  * a sourcemap, or to JSON.stringify.
  */
-let decodedMap;
+function decodedMap(map) {
+    return clone(map, decodedMappings(map));
+}
 /**
  * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
  * a sourcemap, or to JSON.stringify.
  */
-let encodedMap;
-class TraceMap {
-    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;
-        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
-        this.resolvedSources = sources.map((s) => resolve(s || '', from));
-        const { mappings } = parsed;
-        if (typeof mappings === 'string') {
-            this._encoded = mappings;
-            this._decoded = undefined;
-        }
-        else {
-            this._encoded = undefined;
-            this._decoded = maybeSort(mappings, isString);
-        }
-        this._decodedMemo = memoizedState();
-        this._bySources = undefined;
-        this._bySourceMemos = undefined;
-    }
+function encodedMap(map) {
+    return clone(map, encodedMappings(map));
 }
-(() => {
-    encodedMappings = (map) => {
-        var _a;
-        return ((_a = map._encoded) !== null && _a !== void 0 ? _a : (map._encoded = encode(map._decoded)));
-    };
-    decodedMappings = (map) => {
-        return (map._decoded || (map._decoded = decode(map._encoded)));
-    };
-    traceSegment = (map, line, column) => {
-        const decoded = decodedMappings(map);
-        // 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 = traceSegmentInternal(segments, map._decodedMemo, line, column, GREATEST_LOWER_BOUND);
-        return index === -1 ? null : segments[index];
-    };
-    originalPositionFor = (map, { line, column, bias }) => {
-        line--;
-        if (line < 0)
-            throw new Error(LINE_GTR_ZERO);
-        if (column < 0)
-            throw new Error(COL_GTR_EQ_ZERO);
-        const decoded = decodedMappings(map);
-        // 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 OMapping(null, null, null, null);
-        const segments = decoded[line];
-        const index = traceSegmentInternal(segments, 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);
-    };
-    allGeneratedPositionsFor = (map, { source, line, column, bias }) => {
-        // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
-        return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
-    };
-    generatedPositionFor = (map, { source, line, column, bias }) => {
-        return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
-    };
-    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 source = null;
-                let originalLine = null;
-                let originalColumn = null;
-                let name = null;
-                if (seg.length !== 1) {
-                    source = resolvedSources[seg[1]];
-                    originalLine = seg[2] + 1;
-                    originalColumn = seg[3];
-                }
-                if (seg.length === 5)
-                    name = names[seg[4]];
-                cb({
-                    generatedLine,
-                    generatedColumn,
-                    source,
-                    originalLine,
-                    originalColumn,
-                    name,
-                });
-            }
-        }
-    };
-    sourceContentFor = (map, source) => {
-        const { sources, resolvedSources, sourcesContent } = map;
-        if (sourcesContent == null)
-            return null;
-        let index = sources.indexOf(source);
-        if (index === -1)
-            index = resolvedSources.indexOf(source);
-        return index === -1 ? null : sourcesContent[index];
-    };
-    presortedDecodedMap = (map, mapUrl) => {
-        const tracer = new TraceMap(clone(map, []), mapUrl);
-        tracer._decoded = map.mappings;
-        return tracer;
-    };
-    decodedMap = (map) => {
-        return clone(map, decodedMappings(map));
-    };
-    encodedMap = (map) => {
-        return clone(map, encodedMappings(map));
-    };
-    function generatedPosition(map, source, line, column, bias, all) {
-        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 sourceIndex = sources.indexOf(source);
-        if (sourceIndex === -1)
-            sourceIndex = resolvedSources.indexOf(source);
-        if (sourceIndex === -1)
-            return all ? [] : GMapping(null, null);
-        const generated = (map._bySources || (map._bySources = buildBySources(decodedMappings(map), (map._bySourceMemos = sources.map(memoizedState)))));
-        const segments = generated[sourceIndex][line];
-        if (segments == null)
-            return all ? [] : GMapping(null, null);
-        const memo = map._bySourceMemos[sourceIndex];
-        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]);
-    }
-})();
 function clone(map, mappings) {
     return {
         version: map.version,
@@ -501,6 +502,7 @@ function clone(map, mappings) {
         sources: map.sources,
         sourcesContent: map.sourcesContent,
         mappings,
+        ignoreList: map.ignoreList || map.x_google_ignoreList,
     };
 }
 function OMapping(source, line, column, name) {
@@ -547,6 +549,32 @@ function sliceGeneratedPositions(segments, memo, line, column, bias) {
     }
     return result;
 }
+function generatedPosition(map, source, 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 sourceIndex = sources.indexOf(source);
+    if (sourceIndex === -1)
+        sourceIndex = resolvedSources.indexOf(source);
+    if (sourceIndex === -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[sourceIndex][line];
+    if (segments == null)
+        return all ? [] : GMapping(null, null);
+    const memo = cast(map)._bySourceMemos[sourceIndex];
+    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]);
+}
 
-export { AnyMap, GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap, allGeneratedPositionsFor, decodedMap, decodedMappings, eachMapping, encodedMap, encodedMappings, generatedPositionFor, originalPositionFor, presortedDecodedMap, sourceContentFor, traceSegment };
+export { AnyMap, GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap, allGeneratedPositionsFor, decodedMap, decodedMappings, eachMapping, encodedMap, encodedMappings, generatedPositionFor, isIgnored, originalPositionFor, presortedDecodedMap, sourceContentFor, traceSegment };
 //# sourceMappingURL=trace-mapping.mjs.map