@depup/sentry__server-utils 10.70.0-depup.0 → 10.72.0-depup.0

package/build/esm/vendored/source-map/lib/source-map-consumer.js

@@ -0,0 +1,610 @@
+import { __exports as sourceMapConsumer } from '../../../_virtual/source-map-consumer.js';
+import './util.js';
+import './binary-search.js';
+import './array-set.js';
+import './base64-vlq.js';
+import './quick-sort.js';
+import { __exports as util$1 } from '../../../_virtual/util.js';
+import { __exports as binarySearch$1 } from '../../../_virtual/binary-search.js';
+import { __exports as arraySet } from '../../../_virtual/array-set.js';
+import { __exports as base64Vlq } from '../../../_virtual/base64-vlq.js';
+import { __exports as quickSort$1 } from '../../../_virtual/quick-sort.js';
+
+var util = util$1;
+var binarySearch = binarySearch$1;
+var ArraySet = arraySet.ArraySet;
+var base64VLQ = base64Vlq;
+var quickSort = quickSort$1.quickSort;
+function SourceMapConsumer(aSourceMap, aSourceMapURL) {
+  var sourceMap = aSourceMap;
+  if (typeof aSourceMap === "string") {
+    sourceMap = util.parseSourceMapInput(aSourceMap);
+  }
+  return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
+}
+SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
+  return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
+};
+SourceMapConsumer.prototype._version = 3;
+SourceMapConsumer.prototype.__generatedMappings = null;
+Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
+  configurable: true,
+  enumerable: true,
+  get: function() {
+    if (!this.__generatedMappings) {
+      this._parseMappings(this._mappings, this.sourceRoot);
+    }
+    return this.__generatedMappings;
+  }
+});
+SourceMapConsumer.prototype.__originalMappings = null;
+Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
+  configurable: true,
+  enumerable: true,
+  get: function() {
+    if (!this.__originalMappings) {
+      this._parseMappings(this._mappings, this.sourceRoot);
+    }
+    return this.__originalMappings;
+  }
+});
+SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
+  var c = aStr.charAt(index);
+  return c === ";" || c === ",";
+};
+SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+  throw new Error("Subclasses must implement _parseMappings");
+};
+SourceMapConsumer.GENERATED_ORDER = 1;
+SourceMapConsumer.ORIGINAL_ORDER = 2;
+SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+  var context = aContext || null;
+  var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+  var mappings;
+  switch (order) {
+    case SourceMapConsumer.GENERATED_ORDER:
+      mappings = this._generatedMappings;
+      break;
+    case SourceMapConsumer.ORIGINAL_ORDER:
+      mappings = this._originalMappings;
+      break;
+    default:
+      throw new Error("Unknown order of iteration.");
+  }
+  var sourceRoot = this.sourceRoot;
+  mappings.map(function(mapping) {
+    var source = mapping.source === null ? null : this._sources.at(mapping.source);
+    source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
+    return {
+      source,
+      generatedLine: mapping.generatedLine,
+      generatedColumn: mapping.generatedColumn,
+      originalLine: mapping.originalLine,
+      originalColumn: mapping.originalColumn,
+      name: mapping.name === null ? null : this._names.at(mapping.name)
+    };
+  }, this).forEach(aCallback, context);
+};
+SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+  var line = util.getArg(aArgs, "line");
+  var needle = {
+    source: util.getArg(aArgs, "source"),
+    originalLine: line,
+    originalColumn: util.getArg(aArgs, "column", 0)
+  };
+  needle.source = this._findSourceIndex(needle.source);
+  if (needle.source < 0) {
+    return [];
+  }
+  var mappings = [];
+  var index = this._findMapping(
+    needle,
+    this._originalMappings,
+    "originalLine",
+    "originalColumn",
+    util.compareByOriginalPositions,
+    binarySearch.LEAST_UPPER_BOUND
+  );
+  if (index >= 0) {
+    var mapping = this._originalMappings[index];
+    if (aArgs.column === void 0) {
+      var originalLine = mapping.originalLine;
+      while (mapping && mapping.originalLine === originalLine) {
+        mappings.push({
+          line: util.getArg(mapping, "generatedLine", null),
+          column: util.getArg(mapping, "generatedColumn", null),
+          lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+        });
+        mapping = this._originalMappings[++index];
+      }
+    } else {
+      var originalColumn = mapping.originalColumn;
+      while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
+        mappings.push({
+          line: util.getArg(mapping, "generatedLine", null),
+          column: util.getArg(mapping, "generatedColumn", null),
+          lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+        });
+        mapping = this._originalMappings[++index];
+      }
+    }
+  }
+  return mappings;
+};
+sourceMapConsumer.SourceMapConsumer = SourceMapConsumer;
+function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
+  var sourceMap = aSourceMap;
+  if (typeof aSourceMap === "string") {
+    sourceMap = util.parseSourceMapInput(aSourceMap);
+  }
+  var version = util.getArg(sourceMap, "version");
+  var sources = util.getArg(sourceMap, "sources");
+  var names = util.getArg(sourceMap, "names", []);
+  var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
+  var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
+  var mappings = util.getArg(sourceMap, "mappings");
+  var file = util.getArg(sourceMap, "file", null);
+  if (version != this._version) {
+    throw new Error("Unsupported version: " + version);
+  }
+  if (sourceRoot) {
+    sourceRoot = util.normalize(sourceRoot);
+  }
+  sources = sources.map(String).map(util.normalize).map(function(source) {
+    return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
+  });
+  this._names = ArraySet.fromArray(names.map(String), true);
+  this._sources = ArraySet.fromArray(sources, true);
+  this._absoluteSources = this._sources.toArray().map(function(s) {
+    return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+  });
+  this.sourceRoot = sourceRoot;
+  this.sourcesContent = sourcesContent;
+  this._mappings = mappings;
+  this._sourceMapURL = aSourceMapURL;
+  this.file = file;
+}
+BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
+  var relativeSource = aSource;
+  if (this.sourceRoot != null) {
+    relativeSource = util.relative(this.sourceRoot, relativeSource);
+  }
+  if (this._sources.has(relativeSource)) {
+    return this._sources.indexOf(relativeSource);
+  }
+  var i;
+  for (i = 0; i < this._absoluteSources.length; ++i) {
+    if (this._absoluteSources[i] == aSource) {
+      return i;
+    }
+  }
+  return -1;
+};
+BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
+  var smc = Object.create(BasicSourceMapConsumer.prototype);
+  var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
+  var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
+  smc.sourceRoot = aSourceMap._sourceRoot;
+  smc.sourcesContent = aSourceMap._generateSourcesContent(
+    smc._sources.toArray(),
+    smc.sourceRoot
+  );
+  smc.file = aSourceMap._file;
+  smc._sourceMapURL = aSourceMapURL;
+  smc._absoluteSources = smc._sources.toArray().map(function(s) {
+    return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
+  });
+  var generatedMappings = aSourceMap._mappings.toArray().slice();
+  var destGeneratedMappings = smc.__generatedMappings = [];
+  var destOriginalMappings = smc.__originalMappings = [];
+  for (var i = 0, length = generatedMappings.length; i < length; i++) {
+    var srcMapping = generatedMappings[i];
+    var destMapping = new Mapping();
+    destMapping.generatedLine = srcMapping.generatedLine;
+    destMapping.generatedColumn = srcMapping.generatedColumn;
+    if (srcMapping.source) {
+      destMapping.source = sources.indexOf(srcMapping.source);
+      destMapping.originalLine = srcMapping.originalLine;
+      destMapping.originalColumn = srcMapping.originalColumn;
+      if (srcMapping.name) {
+        destMapping.name = names.indexOf(srcMapping.name);
+      }
+      destOriginalMappings.push(destMapping);
+    }
+    destGeneratedMappings.push(destMapping);
+  }
+  quickSort(smc.__originalMappings, util.compareByOriginalPositions);
+  return smc;
+};
+BasicSourceMapConsumer.prototype._version = 3;
+Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", {
+  get: function() {
+    return this._absoluteSources.slice();
+  }
+});
+function Mapping() {
+  this.generatedLine = 0;
+  this.generatedColumn = 0;
+  this.source = null;
+  this.originalLine = null;
+  this.originalColumn = null;
+  this.name = null;
+}
+BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings2(aStr, aSourceRoot) {
+  var generatedLine = 1;
+  var previousGeneratedColumn = 0;
+  var previousOriginalLine = 0;
+  var previousOriginalColumn = 0;
+  var previousSource = 0;
+  var previousName = 0;
+  var length = aStr.length;
+  var index = 0;
+  var cachedSegments = {};
+  var temp = {};
+  var originalMappings = [];
+  var generatedMappings = [];
+  var mapping, str, segment, end, value;
+  while (index < length) {
+    if (aStr.charAt(index) === ";") {
+      generatedLine++;
+      index++;
+      previousGeneratedColumn = 0;
+    } else if (aStr.charAt(index) === ",") {
+      index++;
+    } else {
+      mapping = new Mapping();
+      mapping.generatedLine = generatedLine;
+      for (end = index; end < length; end++) {
+        if (this._charIsMappingSeparator(aStr, end)) {
+          break;
+        }
+      }
+      str = aStr.slice(index, end);
+      segment = cachedSegments[str];
+      if (segment) {
+        index += str.length;
+      } else {
+        segment = [];
+        while (index < end) {
+          base64VLQ.decode(aStr, index, temp);
+          value = temp.value;
+          index = temp.rest;
+          segment.push(value);
+        }
+        if (segment.length === 2) {
+          throw new Error("Found a source, but no line and column");
+        }
+        if (segment.length === 3) {
+          throw new Error("Found a source and line, but no column");
+        }
+        cachedSegments[str] = segment;
+      }
+      mapping.generatedColumn = previousGeneratedColumn + segment[0];
+      previousGeneratedColumn = mapping.generatedColumn;
+      if (segment.length > 1) {
+        mapping.source = previousSource + segment[1];
+        previousSource += segment[1];
+        mapping.originalLine = previousOriginalLine + segment[2];
+        previousOriginalLine = mapping.originalLine;
+        mapping.originalLine += 1;
+        mapping.originalColumn = previousOriginalColumn + segment[3];
+        previousOriginalColumn = mapping.originalColumn;
+        if (segment.length > 4) {
+          mapping.name = previousName + segment[4];
+          previousName += segment[4];
+        }
+      }
+      generatedMappings.push(mapping);
+      if (typeof mapping.originalLine === "number") {
+        originalMappings.push(mapping);
+      }
+    }
+  }
+  quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
+  this.__generatedMappings = generatedMappings;
+  quickSort(originalMappings, util.compareByOriginalPositions);
+  this.__originalMappings = originalMappings;
+};
+BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
+  if (aNeedle[aLineName] <= 0) {
+    throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
+  }
+  if (aNeedle[aColumnName] < 0) {
+    throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
+  }
+  return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
+};
+BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
+  for (var index = 0; index < this._generatedMappings.length; ++index) {
+    var mapping = this._generatedMappings[index];
+    if (index + 1 < this._generatedMappings.length) {
+      var nextMapping = this._generatedMappings[index + 1];
+      if (mapping.generatedLine === nextMapping.generatedLine) {
+        mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
+        continue;
+      }
+    }
+    mapping.lastGeneratedColumn = Infinity;
+  }
+};
+BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
+  var needle = {
+    generatedLine: util.getArg(aArgs, "line"),
+    generatedColumn: util.getArg(aArgs, "column")
+  };
+  var index = this._findMapping(
+    needle,
+    this._generatedMappings,
+    "generatedLine",
+    "generatedColumn",
+    util.compareByGeneratedPositionsDeflated,
+    util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
+  );
+  if (index >= 0) {
+    var mapping = this._generatedMappings[index];
+    if (mapping.generatedLine === needle.generatedLine) {
+      var source = util.getArg(mapping, "source", null);
+      if (source !== null) {
+        source = this._sources.at(source);
+        source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
+      }
+      var name = util.getArg(mapping, "name", null);
+      if (name !== null) {
+        name = this._names.at(name);
+      }
+      return {
+        source,
+        line: util.getArg(mapping, "originalLine", null),
+        column: util.getArg(mapping, "originalColumn", null),
+        name
+      };
+    }
+  }
+  return {
+    source: null,
+    line: null,
+    column: null,
+    name: null
+  };
+};
+BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
+  if (!this.sourcesContent) {
+    return false;
+  }
+  return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
+    return sc == null;
+  });
+};
+BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+  if (!this.sourcesContent) {
+    return null;
+  }
+  var index = this._findSourceIndex(aSource);
+  if (index >= 0) {
+    return this.sourcesContent[index];
+  }
+  var relativeSource = aSource;
+  if (this.sourceRoot != null) {
+    relativeSource = util.relative(this.sourceRoot, relativeSource);
+  }
+  var url;
+  if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
+    var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
+    if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) {
+      return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
+    }
+    if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) {
+      return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
+    }
+  }
+  if (nullOnMissing) {
+    return null;
+  } else {
+    throw new Error('"' + relativeSource + '" is not in the SourceMap.');
+  }
+};
+BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
+  var source = util.getArg(aArgs, "source");
+  source = this._findSourceIndex(source);
+  if (source < 0) {
+    return {
+      line: null,
+      column: null,
+      lastColumn: null
+    };
+  }
+  var needle = {
+    source,
+    originalLine: util.getArg(aArgs, "line"),
+    originalColumn: util.getArg(aArgs, "column")
+  };
+  var index = this._findMapping(
+    needle,
+    this._originalMappings,
+    "originalLine",
+    "originalColumn",
+    util.compareByOriginalPositions,
+    util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
+  );
+  if (index >= 0) {
+    var mapping = this._originalMappings[index];
+    if (mapping.source === needle.source) {
+      return {
+        line: util.getArg(mapping, "generatedLine", null),
+        column: util.getArg(mapping, "generatedColumn", null),
+        lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+      };
+    }
+  }
+  return {
+    line: null,
+    column: null,
+    lastColumn: null
+  };
+};
+sourceMapConsumer.BasicSourceMapConsumer = BasicSourceMapConsumer;
+function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
+  var sourceMap = aSourceMap;
+  if (typeof aSourceMap === "string") {
+    sourceMap = util.parseSourceMapInput(aSourceMap);
+  }
+  var version = util.getArg(sourceMap, "version");
+  var sections = util.getArg(sourceMap, "sections");
+  if (version != this._version) {
+    throw new Error("Unsupported version: " + version);
+  }
+  this._sources = new ArraySet();
+  this._names = new ArraySet();
+  var lastOffset = {
+    line: -1,
+    column: 0
+  };
+  this._sections = sections.map(function(s) {
+    if (s.url) {
+      throw new Error("Support for url field in sections not implemented.");
+    }
+    var offset = util.getArg(s, "offset");
+    var offsetLine = util.getArg(offset, "line");
+    var offsetColumn = util.getArg(offset, "column");
+    if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
+      throw new Error("Section offsets must be ordered and non-overlapping.");
+    }
+    lastOffset = offset;
+    return {
+      generatedOffset: {
+        // The offset fields are 0-based, but we use 1-based indices when
+        // encoding/decoding from VLQ.
+        generatedLine: offsetLine + 1,
+        generatedColumn: offsetColumn + 1
+      },
+      consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
+    };
+  });
+}
+IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
+IndexedSourceMapConsumer.prototype._version = 3;
+Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", {
+  get: function() {
+    var sources = [];
+    for (var i = 0; i < this._sections.length; i++) {
+      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
+        sources.push(this._sections[i].consumer.sources[j]);
+      }
+    }
+    return sources;
+  }
+});
+IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
+  var needle = {
+    generatedLine: util.getArg(aArgs, "line"),
+    generatedColumn: util.getArg(aArgs, "column")
+  };
+  var sectionIndex = binarySearch.search(
+    needle,
+    this._sections,
+    function(needle2, section2) {
+      var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine;
+      if (cmp) {
+        return cmp;
+      }
+      return needle2.generatedColumn - section2.generatedOffset.generatedColumn;
+    }
+  );
+  var section = this._sections[sectionIndex];
+  if (!section) {
+    return {
+      source: null,
+      line: null,
+      column: null,
+      name: null
+    };
+  }
+  return section.consumer.originalPositionFor({
+    line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
+    column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
+    bias: aArgs.bias
+  });
+};
+IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
+  return this._sections.every(function(s) {
+    return s.consumer.hasContentsOfAllSources();
+  });
+};
+IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+  for (var i = 0; i < this._sections.length; i++) {
+    var section = this._sections[i];
+    var content = section.consumer.sourceContentFor(aSource, true);
+    if (content) {
+      return content;
+    }
+  }
+  if (nullOnMissing) {
+    return null;
+  } else {
+    throw new Error('"' + aSource + '" is not in the SourceMap.');
+  }
+};
+IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
+  for (var i = 0; i < this._sections.length; i++) {
+    var section = this._sections[i];
+    if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) {
+      continue;
+    }
+    var generatedPosition = section.consumer.generatedPositionFor(aArgs);
+    if (generatedPosition) {
+      var ret = {
+        line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
+        column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
+      };
+      return ret;
+    }
+  }
+  return {
+    line: null,
+    column: null
+  };
+};
+IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+  this.__generatedMappings = [];
+  this.__originalMappings = [];
+  for (var i = 0; i < this._sections.length; i++) {
+    var section = this._sections[i];
+    var sectionMappings = section.consumer._generatedMappings;
+    for (var j = 0; j < sectionMappings.length; j++) {
+      var mapping = sectionMappings[j];
+      var source = section.consumer._sources.at(mapping.source);
+      source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
+      this._sources.add(source);
+      source = this._sources.indexOf(source);
+      var name = null;
+      if (mapping.name) {
+        name = section.consumer._names.at(mapping.name);
+        this._names.add(name);
+        name = this._names.indexOf(name);
+      }
+      var adjustedMapping = {
+        source,
+        generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
+        generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
+        originalLine: mapping.originalLine,
+        originalColumn: mapping.originalColumn,
+        name
+      };
+      this.__generatedMappings.push(adjustedMapping);
+      if (typeof adjustedMapping.originalLine === "number") {
+        this.__originalMappings.push(adjustedMapping);
+      }
+    }
+  }
+  quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
+  quickSort(this.__originalMappings, util.compareByOriginalPositions);
+};
+sourceMapConsumer.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
+
+export { sourceMapConsumer as default };
+//# sourceMappingURL=source-map-consumer.js.map