@forge-kit/plugin-source-map-prase 0.0.2 → 0.0.4

package/dist/node.js

@@ -0,0 +1,2552 @@
+"use strict";
+const node_perf_hooks = require("node:perf_hooks");
+const promises = require("node:fs/promises");
+const node_path = require("node:path");
+const node_os = require("node:os");
+var PluginOriginType;
+(function(PluginOriginType2) {
+  PluginOriginType2["Local"] = "local";
+  PluginOriginType2["Remote"] = "remote";
+})(PluginOriginType || (PluginOriginType = {}));
+var InvokeType;
+(function(InvokeType2) {
+  InvokeType2["invoke"] = "invoke";
+})(InvokeType || (InvokeType = {}));
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function("return this")();
+var Symbol$1 = root.Symbol;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty = objectProto$1.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$1.toString;
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var objectProto = Object.prototype;
+var nativeObjectToString = objectProto.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+const defineInvokeMethod = (methods) => methods;
+const registerInvokeMethod = (methods) => {
+  if (!process?.send || !process.on)
+    return;
+  const reply = (response) => process.send?.(response);
+  process.on("message", async (message) => {
+    try {
+      if (message.type !== InvokeType.invoke || !message.method)
+        return;
+      const { [message.method]: handler } = methods;
+      if (!handler || !isFunction(handler))
+        throw new Error(`handler is not found: method=${message.method}`);
+      const result = await handler(...message.args || []);
+      reply({ success: true, result });
+    } catch (error) {
+      const errorText = error instanceof Error ? error.stack || error.message : String(error);
+      reply({ success: false, error: errorText });
+    }
+  });
+};
+const MAX_TRACE_DEPTH = 20;
+const DEFAULT_CONTEXT_LINE_RADIUS$1 = 3;
+const normalizePath = (input) => input.replace(/\\/g, "/").trim();
+const getBaseName = (input) => {
+  const normalized = normalizePath(input);
+  const tokens = normalized.split("/");
+  return tokens[tokens.length - 1] || normalized;
+};
+const stripMapExt = (input) => input.endsWith(".map") ? input.slice(0, -4) : input;
+const joinPath = (...parts) => {
+  return parts.map((part) => normalizePath(part)).filter(Boolean).join("/").replace(/\/{2,}/g, "/");
+};
+const registerSourceMap = (input) => {
+  const { registry, key, sourceMapRecord } = input;
+  const normalized = normalizePath(key);
+  if (!normalized) return registry;
+  const nextRegistry = { ...registry, [normalized]: sourceMapRecord };
+  const baseName = getBaseName(normalized);
+  if (!nextRegistry[baseName]) nextRegistry[baseName] = sourceMapRecord;
+  return nextRegistry;
+};
+const listSourceMapRecords = (sourceMaps) => {
+  const map = /* @__PURE__ */ new Map();
+  Object.values(sourceMaps).forEach((record) => {
+    if (map.has(record.mapFileName)) return;
+    map.set(record.mapFileName, record);
+  });
+  return Array.from(map.values());
+};
+const getSourceMapByFileName = (sourceMaps, fileName) => {
+  const normalized = normalizePath(fileName);
+  return sourceMaps[normalized] ?? sourceMaps[getBaseName(normalized)];
+};
+const getSourceMapByMapFileName = (sourceMaps, mapFileName) => {
+  return listSourceMapRecords(sourceMaps).find((item) => item.mapFileName === mapFileName);
+};
+const buildRegistryFromChainSlots = (slots) => {
+  let registry = {};
+  const orderedMapFileNames = [];
+  slots.forEach((slot) => {
+    const { sourceMapRecord: record } = slot;
+    if (!record) return;
+    orderedMapFileNames.push(record.mapFileName);
+    registry = registerSourceMap({ registry, key: record.mapFileName, sourceMapRecord: record });
+    registry = registerSourceMap({ registry, key: stripMapExt(record.mapFileName), sourceMapRecord: record });
+    if (record.rawSourceMap.file) {
+      registry = registerSourceMap({ registry, key: record.rawSourceMap.file, sourceMapRecord: record });
+    }
+  });
+  return { registry, orderedMapFileNames };
+};
+const getAutoEntryFileNameFromSlots = (slots) => {
+  const firstValidSlot = slots.find((slot) => slot.sourceMapRecord);
+  if (!firstValidSlot?.sourceMapRecord) return "";
+  const mappedFile = firstValidSlot.sourceMapRecord.rawSourceMap.file;
+  if (mappedFile) return normalizePath(mappedFile);
+  return stripMapExt(firstValidSlot.sourceMapRecord.mapFileName);
+};
+const toDisplayLocation = (location) => ({ ...location });
+const MAX_EXCERPT_CHARS = 12e3;
+const COLUMN_WINDOW_CHARS = 4e3;
+const truncateLineByColumn = (line, targetColumn = 0) => {
+  if (line.length <= MAX_EXCERPT_CHARS) return line;
+  const halfWindow = Math.floor(COLUMN_WINDOW_CHARS / 2);
+  const start = Math.max(0, targetColumn - halfWindow);
+  const end = Math.min(line.length, start + COLUMN_WINDOW_CHARS);
+  const head = start > 0 ? "…[truncated]…" : "";
+  const tail = end < line.length ? "…[truncated]…" : "";
+  return `${head}${line.slice(start, end)}${tail}`;
+};
+const truncateExcerpt = (code) => {
+  if (code.length <= MAX_EXCERPT_CHARS) return code;
+  return `${code.slice(0, MAX_EXCERPT_CHARS)}
+...[truncated ${code.length - MAX_EXCERPT_CHARS} chars]...`;
+};
+const createCodeExcerpt = (input) => {
+  const {
+    fullCode,
+    targetLine,
+    radius = DEFAULT_CONTEXT_LINE_RADIUS$1,
+    targetColumn = 0
+  } = input;
+  const lines = fullCode.split(/\r?\n/);
+  if (lines.length === 0) {
+    return { code: truncateExcerpt(fullCode), highlightLine: targetLine };
+  }
+  const safeTarget = Math.min(Math.max(targetLine, 1), lines.length);
+  if (lines.length === 1) {
+    return { code: truncateLineByColumn(lines[0], targetColumn), highlightLine: 1 };
+  }
+  const start = Math.max(1, safeTarget - radius);
+  const end = Math.min(lines.length, safeTarget + radius);
+  return {
+    code: truncateExcerpt(lines.slice(start - 1, end).join("\n")),
+    highlightLine: safeTarget - start + 1
+  };
+};
+const findSourceCodeMatch = (hop, sourceMapRecord) => {
+  if (!hop.output) return null;
+  const { sources = [], sourcesContent = [], sourceRoot = "" } = sourceMapRecord.rawSourceMap;
+  const outputFile = normalizePath(hop.output.fileName);
+  const outputBaseName = getBaseName(outputFile);
+  const sourceIndex = sources.findIndex((source) => {
+    const normalizedSource = normalizePath(source);
+    const sourceWithRoot = joinPath(sourceRoot, normalizedSource);
+    return normalizedSource === outputFile || sourceWithRoot === outputFile || outputFile.endsWith(`/${normalizedSource}`) || outputFile.endsWith(`/${sourceWithRoot}`) || getBaseName(normalizedSource) === outputBaseName || getBaseName(sourceWithRoot) === outputBaseName;
+  });
+  if (sourceIndex < 0) return null;
+  const code = sourcesContent[sourceIndex];
+  if (!code) return null;
+  return {
+    code,
+    sourceFile: sources[sourceIndex],
+    location: toDisplayLocation(hop.output)
+  };
+};
+const resolveSourceCodeFromTrace = (traceHops, sourceMaps, options = {}) => {
+  const sourceMapRecords = listSourceMapRecords(sourceMaps);
+  const sourceMapRecordByName = new Map(sourceMapRecords.map((record) => [record.mapFileName, record]));
+  const { onlyLastMap = false, lastMapFileName } = options;
+  for (let index = traceHops.length - 1; index >= 0; index--) {
+    const hop = traceHops[index];
+    if (!hop.output || !hop.mapFileName) continue;
+    if (onlyLastMap && lastMapFileName && hop.mapFileName !== lastMapFileName) continue;
+    const sourceMapRecord = sourceMapRecordByName.get(hop.mapFileName);
+    if (!sourceMapRecord) continue;
+    const match = findSourceCodeMatch(hop, sourceMapRecord);
+    if (!match) continue;
+    return {
+      code: match.code,
+      sourceFile: match.sourceFile,
+      lineNumber: match.location.lineNumber,
+      columnNumber: match.location.columnNumber
+    };
+  }
+  return null;
+};
+const getLastResolvedOutput = (traceHops) => {
+  for (let index = traceHops.length - 1; index >= 0; index--) {
+    const output = traceHops[index].output;
+    if (output) return output;
+  }
+  return null;
+};
+var sourceMap = {};
+var sourceMapGenerator = {};
+var base64Vlq = {};
+var base64 = {};
+var hasRequiredBase64;
+function requireBase64() {
+  if (hasRequiredBase64) return base64;
+  hasRequiredBase64 = 1;
+  var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+  base64.encode = function(number) {
+    if (0 <= number && number < intToCharMap.length) {
+      return intToCharMap[number];
+    }
+    throw new TypeError("Must be between 0 and 63: " + number);
+  };
+  base64.decode = function(charCode) {
+    var bigA = 65;
+    var bigZ = 90;
+    var littleA = 97;
+    var littleZ = 122;
+    var zero = 48;
+    var nine = 57;
+    var plus = 43;
+    var slash = 47;
+    var littleOffset = 26;
+    var numberOffset = 52;
+    if (bigA <= charCode && charCode <= bigZ) {
+      return charCode - bigA;
+    }
+    if (littleA <= charCode && charCode <= littleZ) {
+      return charCode - littleA + littleOffset;
+    }
+    if (zero <= charCode && charCode <= nine) {
+      return charCode - zero + numberOffset;
+    }
+    if (charCode == plus) {
+      return 62;
+    }
+    if (charCode == slash) {
+      return 63;
+    }
+    return -1;
+  };
+  return base64;
+}
+var hasRequiredBase64Vlq;
+function requireBase64Vlq() {
+  if (hasRequiredBase64Vlq) return base64Vlq;
+  hasRequiredBase64Vlq = 1;
+  var base642 = requireBase64();
+  var VLQ_BASE_SHIFT = 5;
+  var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+  var VLQ_BASE_MASK = VLQ_BASE - 1;
+  var VLQ_CONTINUATION_BIT = VLQ_BASE;
+  function toVLQSigned(aValue) {
+    return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
+  }
+  function fromVLQSigned(aValue) {
+    var isNegative = (aValue & 1) === 1;
+    var shifted = aValue >> 1;
+    return isNegative ? -shifted : shifted;
+  }
+  base64Vlq.encode = function base64VLQ_encode(aValue) {
+    var encoded = "";
+    var digit;
+    var vlq = toVLQSigned(aValue);
+    do {
+      digit = vlq & VLQ_BASE_MASK;
+      vlq >>>= VLQ_BASE_SHIFT;
+      if (vlq > 0) {
+        digit |= VLQ_CONTINUATION_BIT;
+      }
+      encoded += base642.encode(digit);
+    } while (vlq > 0);
+    return encoded;
+  };
+  base64Vlq.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
+    var strLen = aStr.length;
+    var result = 0;
+    var shift = 0;
+    var continuation, digit;
+    do {
+      if (aIndex >= strLen) {
+        throw new Error("Expected more digits in base 64 VLQ value.");
+      }
+      digit = base642.decode(aStr.charCodeAt(aIndex++));
+      if (digit === -1) {
+        throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
+      }
+      continuation = !!(digit & VLQ_CONTINUATION_BIT);
+      digit &= VLQ_BASE_MASK;
+      result = result + (digit << shift);
+      shift += VLQ_BASE_SHIFT;
+    } while (continuation);
+    aOutParam.value = fromVLQSigned(result);
+    aOutParam.rest = aIndex;
+  };
+  return base64Vlq;
+}
+var util = {};
+var hasRequiredUtil;
+function requireUtil() {
+  if (hasRequiredUtil) return util;
+  hasRequiredUtil = 1;
+  (function(exports) {
+    function getArg(aArgs, aName, aDefaultValue) {
+      if (aName in aArgs) {
+        return aArgs[aName];
+      } else if (arguments.length === 3) {
+        return aDefaultValue;
+      } else {
+        throw new Error('"' + aName + '" is a required argument.');
+      }
+    }
+    exports.getArg = getArg;
+    var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
+    var dataUrlRegexp = /^data:.+\,.+$/;
+    function urlParse(aUrl) {
+      var match = aUrl.match(urlRegexp);
+      if (!match) {
+        return null;
+      }
+      return {
+        scheme: match[1],
+        auth: match[2],
+        host: match[3],
+        port: match[4],
+        path: match[5]
+      };
+    }
+    exports.urlParse = urlParse;
+    function urlGenerate(aParsedUrl) {
+      var url = "";
+      if (aParsedUrl.scheme) {
+        url += aParsedUrl.scheme + ":";
+      }
+      url += "//";
+      if (aParsedUrl.auth) {
+        url += aParsedUrl.auth + "@";
+      }
+      if (aParsedUrl.host) {
+        url += aParsedUrl.host;
+      }
+      if (aParsedUrl.port) {
+        url += ":" + aParsedUrl.port;
+      }
+      if (aParsedUrl.path) {
+        url += aParsedUrl.path;
+      }
+      return url;
+    }
+    exports.urlGenerate = urlGenerate;
+    var MAX_CACHED_INPUTS = 32;
+    function lruMemoize(f) {
+      var cache = [];
+      return function(input) {
+        for (var i = 0; i < cache.length; i++) {
+          if (cache[i].input === input) {
+            var temp = cache[0];
+            cache[0] = cache[i];
+            cache[i] = temp;
+            return cache[0].result;
+          }
+        }
+        var result = f(input);
+        cache.unshift({
+          input,
+          result
+        });
+        if (cache.length > MAX_CACHED_INPUTS) {
+          cache.pop();
+        }
+        return result;
+      };
+    }
+    var normalize = lruMemoize(function normalize2(aPath) {
+      var path = aPath;
+      var url = urlParse(aPath);
+      if (url) {
+        if (!url.path) {
+          return aPath;
+        }
+        path = url.path;
+      }
+      var isAbsolute = exports.isAbsolute(path);
+      var parts = [];
+      var start = 0;
+      var i = 0;
+      while (true) {
+        start = i;
+        i = path.indexOf("/", start);
+        if (i === -1) {
+          parts.push(path.slice(start));
+          break;
+        } else {
+          parts.push(path.slice(start, i));
+          while (i < path.length && path[i] === "/") {
+            i++;
+          }
+        }
+      }
+      for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
+        part = parts[i];
+        if (part === ".") {
+          parts.splice(i, 1);
+        } else if (part === "..") {
+          up++;
+        } else if (up > 0) {
+          if (part === "") {
+            parts.splice(i + 1, up);
+            up = 0;
+          } else {
+            parts.splice(i, 2);
+            up--;
+          }
+        }
+      }
+      path = parts.join("/");
+      if (path === "") {
+        path = isAbsolute ? "/" : ".";
+      }
+      if (url) {
+        url.path = path;
+        return urlGenerate(url);
+      }
+      return path;
+    });
+    exports.normalize = normalize;
+    function join(aRoot, aPath) {
+      if (aRoot === "") {
+        aRoot = ".";
+      }
+      if (aPath === "") {
+        aPath = ".";
+      }
+      var aPathUrl = urlParse(aPath);
+      var aRootUrl = urlParse(aRoot);
+      if (aRootUrl) {
+        aRoot = aRootUrl.path || "/";
+      }
+      if (aPathUrl && !aPathUrl.scheme) {
+        if (aRootUrl) {
+          aPathUrl.scheme = aRootUrl.scheme;
+        }
+        return urlGenerate(aPathUrl);
+      }
+      if (aPathUrl || aPath.match(dataUrlRegexp)) {
+        return aPath;
+      }
+      if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+        aRootUrl.host = aPath;
+        return urlGenerate(aRootUrl);
+      }
+      var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
+      if (aRootUrl) {
+        aRootUrl.path = joined;
+        return urlGenerate(aRootUrl);
+      }
+      return joined;
+    }
+    exports.join = join;
+    exports.isAbsolute = function(aPath) {
+      return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
+    };
+    function relative(aRoot, aPath) {
+      if (aRoot === "") {
+        aRoot = ".";
+      }
+      aRoot = aRoot.replace(/\/$/, "");
+      var level = 0;
+      while (aPath.indexOf(aRoot + "/") !== 0) {
+        var index = aRoot.lastIndexOf("/");
+        if (index < 0) {
+          return aPath;
+        }
+        aRoot = aRoot.slice(0, index);
+        if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+          return aPath;
+        }
+        ++level;
+      }
+      return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
+    }
+    exports.relative = relative;
+    var supportsNullProto = (function() {
+      var obj = /* @__PURE__ */ Object.create(null);
+      return !("__proto__" in obj);
+    })();
+    function identity(s) {
+      return s;
+    }
+    function toSetString(aStr) {
+      if (isProtoString(aStr)) {
+        return "$" + aStr;
+      }
+      return aStr;
+    }
+    exports.toSetString = supportsNullProto ? identity : toSetString;
+    function fromSetString(aStr) {
+      if (isProtoString(aStr)) {
+        return aStr.slice(1);
+      }
+      return aStr;
+    }
+    exports.fromSetString = supportsNullProto ? identity : fromSetString;
+    function isProtoString(s) {
+      if (!s) {
+        return false;
+      }
+      var length = s.length;
+      if (length < 9) {
+        return false;
+      }
+      if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
+        return false;
+      }
+      for (var i = length - 10; i >= 0; i--) {
+        if (s.charCodeAt(i) !== 36) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+      var cmp = strcmp(mappingA.source, mappingB.source);
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalLine - mappingB.originalLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalColumn - mappingB.originalColumn;
+      if (cmp !== 0 || onlyCompareOriginal) {
+        return cmp;
+      }
+      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.generatedLine - mappingB.generatedLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      return strcmp(mappingA.name, mappingB.name);
+    }
+    exports.compareByOriginalPositions = compareByOriginalPositions;
+    function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {
+      var cmp;
+      cmp = mappingA.originalLine - mappingB.originalLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalColumn - mappingB.originalColumn;
+      if (cmp !== 0 || onlyCompareOriginal) {
+        return cmp;
+      }
+      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.generatedLine - mappingB.generatedLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      return strcmp(mappingA.name, mappingB.name);
+    }
+    exports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;
+    function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
+      var cmp = mappingA.generatedLine - mappingB.generatedLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+      if (cmp !== 0 || onlyCompareGenerated) {
+        return cmp;
+      }
+      cmp = strcmp(mappingA.source, mappingB.source);
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalLine - mappingB.originalLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalColumn - mappingB.originalColumn;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      return strcmp(mappingA.name, mappingB.name);
+    }
+    exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
+    function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {
+      var cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+      if (cmp !== 0 || onlyCompareGenerated) {
+        return cmp;
+      }
+      cmp = strcmp(mappingA.source, mappingB.source);
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalLine - mappingB.originalLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalColumn - mappingB.originalColumn;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      return strcmp(mappingA.name, mappingB.name);
+    }
+    exports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;
+    function strcmp(aStr1, aStr2) {
+      if (aStr1 === aStr2) {
+        return 0;
+      }
+      if (aStr1 === null) {
+        return 1;
+      }
+      if (aStr2 === null) {
+        return -1;
+      }
+      if (aStr1 > aStr2) {
+        return 1;
+      }
+      return -1;
+    }
+    function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+      var cmp = mappingA.generatedLine - mappingB.generatedLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = strcmp(mappingA.source, mappingB.source);
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalLine - mappingB.originalLine;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      cmp = mappingA.originalColumn - mappingB.originalColumn;
+      if (cmp !== 0) {
+        return cmp;
+      }
+      return strcmp(mappingA.name, mappingB.name);
+    }
+    exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+    function parseSourceMapInput(str) {
+      return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
+    }
+    exports.parseSourceMapInput = parseSourceMapInput;
+    function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+      sourceURL = sourceURL || "";
+      if (sourceRoot) {
+        if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
+          sourceRoot += "/";
+        }
+        sourceURL = sourceRoot + sourceURL;
+      }
+      if (sourceMapURL) {
+        var parsed = urlParse(sourceMapURL);
+        if (!parsed) {
+          throw new Error("sourceMapURL could not be parsed");
+        }
+        if (parsed.path) {
+          var index = parsed.path.lastIndexOf("/");
+          if (index >= 0) {
+            parsed.path = parsed.path.substring(0, index + 1);
+          }
+        }
+        sourceURL = join(urlGenerate(parsed), sourceURL);
+      }
+      return normalize(sourceURL);
+    }
+    exports.computeSourceURL = computeSourceURL;
+  })(util);
+  return util;
+}
+var arraySet = {};
+var hasRequiredArraySet;
+function requireArraySet() {
+  if (hasRequiredArraySet) return arraySet;
+  hasRequiredArraySet = 1;
+  var util2 = requireUtil();
+  var has = Object.prototype.hasOwnProperty;
+  var hasNativeMap = typeof Map !== "undefined";
+  function ArraySet() {
+    this._array = [];
+    this._set = hasNativeMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null);
+  }
+  ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
+    var set = new ArraySet();
+    for (var i = 0, len = aArray.length; i < len; i++) {
+      set.add(aArray[i], aAllowDuplicates);
+    }
+    return set;
+  };
+  ArraySet.prototype.size = function ArraySet_size() {
+    return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
+  };
+  ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
+    var sStr = hasNativeMap ? aStr : util2.toSetString(aStr);
+    var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+    var idx = this._array.length;
+    if (!isDuplicate || aAllowDuplicates) {
+      this._array.push(aStr);
+    }
+    if (!isDuplicate) {
+      if (hasNativeMap) {
+        this._set.set(aStr, idx);
+      } else {
+        this._set[sStr] = idx;
+      }
+    }
+  };
+  ArraySet.prototype.has = function ArraySet_has(aStr) {
+    if (hasNativeMap) {
+      return this._set.has(aStr);
+    } else {
+      var sStr = util2.toSetString(aStr);
+      return has.call(this._set, sStr);
+    }
+  };
+  ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+    if (hasNativeMap) {
+      var idx = this._set.get(aStr);
+      if (idx >= 0) {
+        return idx;
+      }
+    } else {
+      var sStr = util2.toSetString(aStr);
+      if (has.call(this._set, sStr)) {
+        return this._set[sStr];
+      }
+    }
+    throw new Error('"' + aStr + '" is not in the set.');
+  };
+  ArraySet.prototype.at = function ArraySet_at(aIdx) {
+    if (aIdx >= 0 && aIdx < this._array.length) {
+      return this._array[aIdx];
+    }
+    throw new Error("No element indexed by " + aIdx);
+  };
+  ArraySet.prototype.toArray = function ArraySet_toArray() {
+    return this._array.slice();
+  };
+  arraySet.ArraySet = ArraySet;
+  return arraySet;
+}
+var mappingList = {};
+var hasRequiredMappingList;
+function requireMappingList() {
+  if (hasRequiredMappingList) return mappingList;
+  hasRequiredMappingList = 1;
+  var util2 = requireUtil();
+  function generatedPositionAfter(mappingA, mappingB) {
+    var lineA = mappingA.generatedLine;
+    var lineB = mappingB.generatedLine;
+    var columnA = mappingA.generatedColumn;
+    var columnB = mappingB.generatedColumn;
+    return lineB > lineA || lineB == lineA && columnB >= columnA || util2.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
+  }
+  function MappingList() {
+    this._array = [];
+    this._sorted = true;
+    this._last = { generatedLine: -1, generatedColumn: 0 };
+  }
+  MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
+    this._array.forEach(aCallback, aThisArg);
+  };
+  MappingList.prototype.add = function MappingList_add(aMapping) {
+    if (generatedPositionAfter(this._last, aMapping)) {
+      this._last = aMapping;
+      this._array.push(aMapping);
+    } else {
+      this._sorted = false;
+      this._array.push(aMapping);
+    }
+  };
+  MappingList.prototype.toArray = function MappingList_toArray() {
+    if (!this._sorted) {
+      this._array.sort(util2.compareByGeneratedPositionsInflated);
+      this._sorted = true;
+    }
+    return this._array;
+  };
+  mappingList.MappingList = MappingList;
+  return mappingList;
+}
+var hasRequiredSourceMapGenerator;
+function requireSourceMapGenerator() {
+  if (hasRequiredSourceMapGenerator) return sourceMapGenerator;
+  hasRequiredSourceMapGenerator = 1;
+  var base64VLQ = requireBase64Vlq();
+  var util2 = requireUtil();
+  var ArraySet = requireArraySet().ArraySet;
+  var MappingList = requireMappingList().MappingList;
+  function SourceMapGenerator(aArgs) {
+    if (!aArgs) {
+      aArgs = {};
+    }
+    this._file = util2.getArg(aArgs, "file", null);
+    this._sourceRoot = util2.getArg(aArgs, "sourceRoot", null);
+    this._skipValidation = util2.getArg(aArgs, "skipValidation", false);
+    this._ignoreInvalidMapping = util2.getArg(aArgs, "ignoreInvalidMapping", false);
+    this._sources = new ArraySet();
+    this._names = new ArraySet();
+    this._mappings = new MappingList();
+    this._sourcesContents = null;
+  }
+  SourceMapGenerator.prototype._version = 3;
+  SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer, generatorOps) {
+    var sourceRoot = aSourceMapConsumer.sourceRoot;
+    var generator = new SourceMapGenerator(Object.assign(generatorOps || {}, {
+      file: aSourceMapConsumer.file,
+      sourceRoot
+    }));
+    aSourceMapConsumer.eachMapping(function(mapping) {
+      var newMapping = {
+        generated: {
+          line: mapping.generatedLine,
+          column: mapping.generatedColumn
+        }
+      };
+      if (mapping.source != null) {
+        newMapping.source = mapping.source;
+        if (sourceRoot != null) {
+          newMapping.source = util2.relative(sourceRoot, newMapping.source);
+        }
+        newMapping.original = {
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        };
+        if (mapping.name != null) {
+          newMapping.name = mapping.name;
+        }
+      }
+      generator.addMapping(newMapping);
+    });
+    aSourceMapConsumer.sources.forEach(function(sourceFile) {
+      var sourceRelative = sourceFile;
+      if (sourceRoot !== null) {
+        sourceRelative = util2.relative(sourceRoot, sourceFile);
+      }
+      if (!generator._sources.has(sourceRelative)) {
+        generator._sources.add(sourceRelative);
+      }
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        generator.setSourceContent(sourceFile, content);
+      }
+    });
+    return generator;
+  };
+  SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
+    var generated = util2.getArg(aArgs, "generated");
+    var original = util2.getArg(aArgs, "original", null);
+    var source = util2.getArg(aArgs, "source", null);
+    var name = util2.getArg(aArgs, "name", null);
+    if (!this._skipValidation) {
+      if (this._validateMapping(generated, original, source, name) === false) {
+        return;
+      }
+    }
+    if (source != null) {
+      source = String(source);
+      if (!this._sources.has(source)) {
+        this._sources.add(source);
+      }
+    }
+    if (name != null) {
+      name = String(name);
+      if (!this._names.has(name)) {
+        this._names.add(name);
+      }
+    }
+    this._mappings.add({
+      generatedLine: generated.line,
+      generatedColumn: generated.column,
+      originalLine: original != null && original.line,
+      originalColumn: original != null && original.column,
+      source,
+      name
+    });
+  };
+  SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+    var source = aSourceFile;
+    if (this._sourceRoot != null) {
+      source = util2.relative(this._sourceRoot, source);
+    }
+    if (aSourceContent != null) {
+      if (!this._sourcesContents) {
+        this._sourcesContents = /* @__PURE__ */ Object.create(null);
+      }
+      this._sourcesContents[util2.toSetString(source)] = aSourceContent;
+    } else if (this._sourcesContents) {
+      delete this._sourcesContents[util2.toSetString(source)];
+      if (Object.keys(this._sourcesContents).length === 0) {
+        this._sourcesContents = null;
+      }
+    }
+  };
+  SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+    var sourceFile = aSourceFile;
+    if (aSourceFile == null) {
+      if (aSourceMapConsumer.file == null) {
+        throw new Error(
+          `SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`
+        );
+      }
+      sourceFile = aSourceMapConsumer.file;
+    }
+    var sourceRoot = this._sourceRoot;
+    if (sourceRoot != null) {
+      sourceFile = util2.relative(sourceRoot, sourceFile);
+    }
+    var newSources = new ArraySet();
+    var newNames = new ArraySet();
+    this._mappings.unsortedForEach(function(mapping) {
+      if (mapping.source === sourceFile && mapping.originalLine != null) {
+        var original = aSourceMapConsumer.originalPositionFor({
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        });
+        if (original.source != null) {
+          mapping.source = original.source;
+          if (aSourceMapPath != null) {
+            mapping.source = util2.join(aSourceMapPath, mapping.source);
+          }
+          if (sourceRoot != null) {
+            mapping.source = util2.relative(sourceRoot, mapping.source);
+          }
+          mapping.originalLine = original.line;
+          mapping.originalColumn = original.column;
+          if (original.name != null) {
+            mapping.name = original.name;
+          }
+        }
+      }
+      var source = mapping.source;
+      if (source != null && !newSources.has(source)) {
+        newSources.add(source);
+      }
+      var name = mapping.name;
+      if (name != null && !newNames.has(name)) {
+        newNames.add(name);
+      }
+    }, this);
+    this._sources = newSources;
+    this._names = newNames;
+    aSourceMapConsumer.sources.forEach(function(sourceFile2) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile2);
+      if (content != null) {
+        if (aSourceMapPath != null) {
+          sourceFile2 = util2.join(aSourceMapPath, sourceFile2);
+        }
+        if (sourceRoot != null) {
+          sourceFile2 = util2.relative(sourceRoot, sourceFile2);
+        }
+        this.setSourceContent(sourceFile2, content);
+      }
+    }, this);
+  };
+  SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
+    if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
+      var message = "original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.";
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== "undefined" && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message);
+      }
+    }
+    if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
+      return;
+    } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
+      return;
+    } else {
+      var message = "Invalid mapping: " + JSON.stringify({
+        generated: aGenerated,
+        source: aSource,
+        original: aOriginal,
+        name: aName
+      });
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== "undefined" && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message);
+      }
+    }
+  };
+  SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
+    var previousGeneratedColumn = 0;
+    var previousGeneratedLine = 1;
+    var previousOriginalColumn = 0;
+    var previousOriginalLine = 0;
+    var previousName = 0;
+    var previousSource = 0;
+    var result = "";
+    var next;
+    var mapping;
+    var nameIdx;
+    var sourceIdx;
+    var mappings = this._mappings.toArray();
+    for (var i = 0, len = mappings.length; i < len; i++) {
+      mapping = mappings[i];
+      next = "";
+      if (mapping.generatedLine !== previousGeneratedLine) {
+        previousGeneratedColumn = 0;
+        while (mapping.generatedLine !== previousGeneratedLine) {
+          next += ";";
+          previousGeneratedLine++;
+        }
+      } else {
+        if (i > 0) {
+          if (!util2.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+            continue;
+          }
+          next += ",";
+        }
+      }
+      next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
+      previousGeneratedColumn = mapping.generatedColumn;
+      if (mapping.source != null) {
+        sourceIdx = this._sources.indexOf(mapping.source);
+        next += base64VLQ.encode(sourceIdx - previousSource);
+        previousSource = sourceIdx;
+        next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
+        previousOriginalLine = mapping.originalLine - 1;
+        next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
+        previousOriginalColumn = mapping.originalColumn;
+        if (mapping.name != null) {
+          nameIdx = this._names.indexOf(mapping.name);
+          next += base64VLQ.encode(nameIdx - previousName);
+          previousName = nameIdx;
+        }
+      }
+      result += next;
+    }
+    return result;
+  };
+  SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
+    return aSources.map(function(source) {
+      if (!this._sourcesContents) {
+        return null;
+      }
+      if (aSourceRoot != null) {
+        source = util2.relative(aSourceRoot, source);
+      }
+      var key = util2.toSetString(source);
+      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
+    }, this);
+  };
+  SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
+    var map = {
+      version: this._version,
+      sources: this._sources.toArray(),
+      names: this._names.toArray(),
+      mappings: this._serializeMappings()
+    };
+    if (this._file != null) {
+      map.file = this._file;
+    }
+    if (this._sourceRoot != null) {
+      map.sourceRoot = this._sourceRoot;
+    }
+    if (this._sourcesContents) {
+      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+    }
+    return map;
+  };
+  SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
+    return JSON.stringify(this.toJSON());
+  };
+  sourceMapGenerator.SourceMapGenerator = SourceMapGenerator;
+  return sourceMapGenerator;
+}
+var sourceMapConsumer = {};
+var binarySearch = {};
+var hasRequiredBinarySearch;
+function requireBinarySearch() {
+  if (hasRequiredBinarySearch) return binarySearch;
+  hasRequiredBinarySearch = 1;
+  (function(exports) {
+    exports.GREATEST_LOWER_BOUND = 1;
+    exports.LEAST_UPPER_BOUND = 2;
+    function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
+      var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+      var cmp = aCompare(aNeedle, aHaystack[mid], true);
+      if (cmp === 0) {
+        return mid;
+      } else if (cmp > 0) {
+        if (aHigh - mid > 1) {
+          return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
+        }
+        if (aBias == exports.LEAST_UPPER_BOUND) {
+          return aHigh < aHaystack.length ? aHigh : -1;
+        } else {
+          return mid;
+        }
+      } else {
+        if (mid - aLow > 1) {
+          return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
+        }
+        if (aBias == exports.LEAST_UPPER_BOUND) {
+          return mid;
+        } else {
+          return aLow < 0 ? -1 : aLow;
+        }
+      }
+    }
+    exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+      if (aHaystack.length === 0) {
+        return -1;
+      }
+      var index = recursiveSearch(
+        -1,
+        aHaystack.length,
+        aNeedle,
+        aHaystack,
+        aCompare,
+        aBias || exports.GREATEST_LOWER_BOUND
+      );
+      if (index < 0) {
+        return -1;
+      }
+      while (index - 1 >= 0) {
+        if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+          break;
+        }
+        --index;
+      }
+      return index;
+    };
+  })(binarySearch);
+  return binarySearch;
+}
+var quickSort = {};
+var hasRequiredQuickSort;
+function requireQuickSort() {
+  if (hasRequiredQuickSort) return quickSort;
+  hasRequiredQuickSort = 1;
+  function SortTemplate(comparator) {
+    function swap(ary, x, y) {
+      var temp = ary[x];
+      ary[x] = ary[y];
+      ary[y] = temp;
+    }
+    function randomIntInRange(low, high) {
+      return Math.round(low + Math.random() * (high - low));
+    }
+    function doQuickSort(ary, comparator2, p, r) {
+      if (p < r) {
+        var pivotIndex = randomIntInRange(p, r);
+        var i = p - 1;
+        swap(ary, pivotIndex, r);
+        var pivot = ary[r];
+        for (var j = p; j < r; j++) {
+          if (comparator2(ary[j], pivot, false) <= 0) {
+            i += 1;
+            swap(ary, i, j);
+          }
+        }
+        swap(ary, i + 1, j);
+        var q = i + 1;
+        doQuickSort(ary, comparator2, p, q - 1);
+        doQuickSort(ary, comparator2, q + 1, r);
+      }
+    }
+    return doQuickSort;
+  }
+  function cloneSort(comparator) {
+    let template = SortTemplate.toString();
+    let templateFn = new Function(`return ${template}`)();
+    return templateFn(comparator);
+  }
+  let sortCache = /* @__PURE__ */ new WeakMap();
+  quickSort.quickSort = function(ary, comparator, start = 0) {
+    let doQuickSort = sortCache.get(comparator);
+    if (doQuickSort === void 0) {
+      doQuickSort = cloneSort(comparator);
+      sortCache.set(comparator, doQuickSort);
+    }
+    doQuickSort(ary, comparator, start, ary.length - 1);
+  };
+  return quickSort;
+}
+var hasRequiredSourceMapConsumer;
+function requireSourceMapConsumer() {
+  if (hasRequiredSourceMapConsumer) return sourceMapConsumer;
+  hasRequiredSourceMapConsumer = 1;
+  var util2 = requireUtil();
+  var binarySearch2 = requireBinarySearch();
+  var ArraySet = requireArraySet().ArraySet;
+  var base64VLQ = requireBase64Vlq();
+  var quickSort2 = requireQuickSort().quickSort;
+  function SourceMapConsumer(aSourceMap, aSourceMapURL) {
+    var sourceMap2 = aSourceMap;
+    if (typeof aSourceMap === "string") {
+      sourceMap2 = util2.parseSourceMapInput(aSourceMap);
+    }
+    return sourceMap2.sections != null ? new IndexedSourceMapConsumer(sourceMap2, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap2, 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;
+    var boundCallback = aCallback.bind(context);
+    var names = this._names;
+    var sources = this._sources;
+    var sourceMapURL = this._sourceMapURL;
+    for (var i = 0, n = mappings.length; i < n; i++) {
+      var mapping = mappings[i];
+      var source = mapping.source === null ? null : sources.at(mapping.source);
+      if (source !== null) {
+        source = util2.computeSourceURL(sourceRoot, source, sourceMapURL);
+      }
+      boundCallback({
+        source,
+        generatedLine: mapping.generatedLine,
+        generatedColumn: mapping.generatedColumn,
+        originalLine: mapping.originalLine,
+        originalColumn: mapping.originalColumn,
+        name: mapping.name === null ? null : names.at(mapping.name)
+      });
+    }
+  };
+  SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+    var line = util2.getArg(aArgs, "line");
+    var needle = {
+      source: util2.getArg(aArgs, "source"),
+      originalLine: line,
+      originalColumn: util2.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",
+      util2.compareByOriginalPositions,
+      binarySearch2.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: util2.getArg(mapping, "generatedLine", null),
+            column: util2.getArg(mapping, "generatedColumn", null),
+            lastColumn: util2.getArg(mapping, "lastGeneratedColumn", null)
+          });
+          mapping = this._originalMappings[++index];
+        }
+      } else {
+        var originalColumn = mapping.originalColumn;
+        while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
+          mappings.push({
+            line: util2.getArg(mapping, "generatedLine", null),
+            column: util2.getArg(mapping, "generatedColumn", null),
+            lastColumn: util2.getArg(mapping, "lastGeneratedColumn", null)
+          });
+          mapping = this._originalMappings[++index];
+        }
+      }
+    }
+    return mappings;
+  };
+  sourceMapConsumer.SourceMapConsumer = SourceMapConsumer;
+  function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
+    var sourceMap2 = aSourceMap;
+    if (typeof aSourceMap === "string") {
+      sourceMap2 = util2.parseSourceMapInput(aSourceMap);
+    }
+    var version = util2.getArg(sourceMap2, "version");
+    var sources = util2.getArg(sourceMap2, "sources");
+    var names = util2.getArg(sourceMap2, "names", []);
+    var sourceRoot = util2.getArg(sourceMap2, "sourceRoot", null);
+    var sourcesContent = util2.getArg(sourceMap2, "sourcesContent", null);
+    var mappings = util2.getArg(sourceMap2, "mappings");
+    var file = util2.getArg(sourceMap2, "file", null);
+    if (version != this._version) {
+      throw new Error("Unsupported version: " + version);
+    }
+    if (sourceRoot) {
+      sourceRoot = util2.normalize(sourceRoot);
+    }
+    sources = sources.map(String).map(util2.normalize).map(function(source) {
+      return sourceRoot && util2.isAbsolute(sourceRoot) && util2.isAbsolute(source) ? util2.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 util2.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 = util2.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 util2.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);
+    }
+    quickSort2(smc.__originalMappings, util2.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;
+  }
+  const compareGenerated = util2.compareByGeneratedPositionsDeflatedNoLine;
+  function sortGenerated(array, start) {
+    let l = array.length;
+    let n = array.length - start;
+    if (n <= 1) {
+      return;
+    } else if (n == 2) {
+      let a = array[start];
+      let b = array[start + 1];
+      if (compareGenerated(a, b) > 0) {
+        array[start] = b;
+        array[start + 1] = a;
+      }
+    } else if (n < 20) {
+      for (let i = start; i < l; i++) {
+        for (let j = i; j > start; j--) {
+          let a = array[j - 1];
+          let b = array[j];
+          if (compareGenerated(a, b) <= 0) {
+            break;
+          }
+          array[j - 1] = b;
+          array[j] = a;
+        }
+      }
+    } else {
+      quickSort2(array, compareGenerated, start);
+    }
+  }
+  BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(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 temp = {};
+    var originalMappings = [];
+    var generatedMappings = [];
+    var mapping, segment, end, value;
+    let subarrayStart = 0;
+    while (index < length) {
+      if (aStr.charAt(index) === ";") {
+        generatedLine++;
+        index++;
+        previousGeneratedColumn = 0;
+        sortGenerated(generatedMappings, subarrayStart);
+        subarrayStart = generatedMappings.length;
+      } 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;
+          }
+        }
+        aStr.slice(index, end);
+        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");
+        }
+        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") {
+          let currentSource = mapping.source;
+          while (originalMappings.length <= currentSource) {
+            originalMappings.push(null);
+          }
+          if (originalMappings[currentSource] === null) {
+            originalMappings[currentSource] = [];
+          }
+          originalMappings[currentSource].push(mapping);
+        }
+      }
+    }
+    sortGenerated(generatedMappings, subarrayStart);
+    this.__generatedMappings = generatedMappings;
+    for (var i = 0; i < originalMappings.length; i++) {
+      if (originalMappings[i] != null) {
+        quickSort2(originalMappings[i], util2.compareByOriginalPositionsNoSource);
+      }
+    }
+    this.__originalMappings = [].concat(...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 binarySearch2.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: util2.getArg(aArgs, "line"),
+      generatedColumn: util2.getArg(aArgs, "column")
+    };
+    var index = this._findMapping(
+      needle,
+      this._generatedMappings,
+      "generatedLine",
+      "generatedColumn",
+      util2.compareByGeneratedPositionsDeflated,
+      util2.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
+    );
+    if (index >= 0) {
+      var mapping = this._generatedMappings[index];
+      if (mapping.generatedLine === needle.generatedLine) {
+        var source = util2.getArg(mapping, "source", null);
+        if (source !== null) {
+          source = this._sources.at(source);
+          source = util2.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
+        }
+        var name = util2.getArg(mapping, "name", null);
+        if (name !== null) {
+          name = this._names.at(name);
+        }
+        return {
+          source,
+          line: util2.getArg(mapping, "originalLine", null),
+          column: util2.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 = util2.relative(this.sourceRoot, relativeSource);
+    }
+    var url;
+    if (this.sourceRoot != null && (url = util2.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 = util2.getArg(aArgs, "source");
+    source = this._findSourceIndex(source);
+    if (source < 0) {
+      return {
+        line: null,
+        column: null,
+        lastColumn: null
+      };
+    }
+    var needle = {
+      source,
+      originalLine: util2.getArg(aArgs, "line"),
+      originalColumn: util2.getArg(aArgs, "column")
+    };
+    var index = this._findMapping(
+      needle,
+      this._originalMappings,
+      "originalLine",
+      "originalColumn",
+      util2.compareByOriginalPositions,
+      util2.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
+    );
+    if (index >= 0) {
+      var mapping = this._originalMappings[index];
+      if (mapping.source === needle.source) {
+        return {
+          line: util2.getArg(mapping, "generatedLine", null),
+          column: util2.getArg(mapping, "generatedColumn", null),
+          lastColumn: util2.getArg(mapping, "lastGeneratedColumn", null)
+        };
+      }
+    }
+    return {
+      line: null,
+      column: null,
+      lastColumn: null
+    };
+  };
+  sourceMapConsumer.BasicSourceMapConsumer = BasicSourceMapConsumer;
+  function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
+    var sourceMap2 = aSourceMap;
+    if (typeof aSourceMap === "string") {
+      sourceMap2 = util2.parseSourceMapInput(aSourceMap);
+    }
+    var version = util2.getArg(sourceMap2, "version");
+    var sections = util2.getArg(sourceMap2, "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 = util2.getArg(s, "offset");
+      var offsetLine = util2.getArg(offset, "line");
+      var offsetColumn = util2.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(util2.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: util2.getArg(aArgs, "line"),
+      generatedColumn: util2.getArg(aArgs, "column")
+    };
+    var sectionIndex = binarySearch2.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 || 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(util2.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);
+        if (source !== null) {
+          source = util2.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);
+        }
+      }
+    }
+    quickSort2(this.__generatedMappings, util2.compareByGeneratedPositionsDeflated);
+    quickSort2(this.__originalMappings, util2.compareByOriginalPositions);
+  };
+  sourceMapConsumer.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
+  return sourceMapConsumer;
+}
+var sourceNode = {};
+var hasRequiredSourceNode;
+function requireSourceNode() {
+  if (hasRequiredSourceNode) return sourceNode;
+  hasRequiredSourceNode = 1;
+  var SourceMapGenerator = requireSourceMapGenerator().SourceMapGenerator;
+  var util2 = requireUtil();
+  var REGEX_NEWLINE = /(\r?\n)/;
+  var NEWLINE_CODE = 10;
+  var isSourceNode = "$$$isSourceNode$$$";
+  function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+    this.children = [];
+    this.sourceContents = {};
+    this.line = aLine == null ? null : aLine;
+    this.column = aColumn == null ? null : aColumn;
+    this.source = aSource == null ? null : aSource;
+    this.name = aName == null ? null : aName;
+    this[isSourceNode] = true;
+    if (aChunks != null) this.add(aChunks);
+  }
+  SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
+    var node = new SourceNode();
+    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+    var remainingLinesIndex = 0;
+    var shiftNextLine = function() {
+      var lineContents = getNextLine();
+      var newLine = getNextLine() || "";
+      return lineContents + newLine;
+      function getNextLine() {
+        return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0;
+      }
+    };
+    var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+    var lastMapping = null;
+    aSourceMapConsumer.eachMapping(function(mapping) {
+      if (lastMapping !== null) {
+        if (lastGeneratedLine < mapping.generatedLine) {
+          addMappingWithCode(lastMapping, shiftNextLine());
+          lastGeneratedLine++;
+          lastGeneratedColumn = 0;
+        } else {
+          var nextLine = remainingLines[remainingLinesIndex] || "";
+          var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
+          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
+          lastGeneratedColumn = mapping.generatedColumn;
+          addMappingWithCode(lastMapping, code);
+          lastMapping = mapping;
+          return;
+        }
+      }
+      while (lastGeneratedLine < mapping.generatedLine) {
+        node.add(shiftNextLine());
+        lastGeneratedLine++;
+      }
+      if (lastGeneratedColumn < mapping.generatedColumn) {
+        var nextLine = remainingLines[remainingLinesIndex] || "";
+        node.add(nextLine.substr(0, mapping.generatedColumn));
+        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+        lastGeneratedColumn = mapping.generatedColumn;
+      }
+      lastMapping = mapping;
+    }, this);
+    if (remainingLinesIndex < remainingLines.length) {
+      if (lastMapping) {
+        addMappingWithCode(lastMapping, shiftNextLine());
+      }
+      node.add(remainingLines.splice(remainingLinesIndex).join(""));
+    }
+    aSourceMapConsumer.sources.forEach(function(sourceFile) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        if (aRelativePath != null) {
+          sourceFile = util2.join(aRelativePath, sourceFile);
+        }
+        node.setSourceContent(sourceFile, content);
+      }
+    });
+    return node;
+    function addMappingWithCode(mapping, code) {
+      if (mapping === null || mapping.source === void 0) {
+        node.add(code);
+      } else {
+        var source = aRelativePath ? util2.join(aRelativePath, mapping.source) : mapping.source;
+        node.add(new SourceNode(
+          mapping.originalLine,
+          mapping.originalColumn,
+          source,
+          code,
+          mapping.name
+        ));
+      }
+    }
+  };
+  SourceNode.prototype.add = function SourceNode_add(aChunk) {
+    if (Array.isArray(aChunk)) {
+      aChunk.forEach(function(chunk) {
+        this.add(chunk);
+      }, this);
+    } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+      if (aChunk) {
+        this.children.push(aChunk);
+      }
+    } else {
+      throw new TypeError(
+        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+      );
+    }
+    return this;
+  };
+  SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+    if (Array.isArray(aChunk)) {
+      for (var i = aChunk.length - 1; i >= 0; i--) {
+        this.prepend(aChunk[i]);
+      }
+    } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+      this.children.unshift(aChunk);
+    } else {
+      throw new TypeError(
+        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+      );
+    }
+    return this;
+  };
+  SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+    var chunk;
+    for (var i = 0, len = this.children.length; i < len; i++) {
+      chunk = this.children[i];
+      if (chunk[isSourceNode]) {
+        chunk.walk(aFn);
+      } else {
+        if (chunk !== "") {
+          aFn(chunk, {
+            source: this.source,
+            line: this.line,
+            column: this.column,
+            name: this.name
+          });
+        }
+      }
+    }
+  };
+  SourceNode.prototype.join = function SourceNode_join(aSep) {
+    var newChildren;
+    var i;
+    var len = this.children.length;
+    if (len > 0) {
+      newChildren = [];
+      for (i = 0; i < len - 1; i++) {
+        newChildren.push(this.children[i]);
+        newChildren.push(aSep);
+      }
+      newChildren.push(this.children[i]);
+      this.children = newChildren;
+    }
+    return this;
+  };
+  SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+    var lastChild = this.children[this.children.length - 1];
+    if (lastChild[isSourceNode]) {
+      lastChild.replaceRight(aPattern, aReplacement);
+    } else if (typeof lastChild === "string") {
+      this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+    } else {
+      this.children.push("".replace(aPattern, aReplacement));
+    }
+    return this;
+  };
+  SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+    this.sourceContents[util2.toSetString(aSourceFile)] = aSourceContent;
+  };
+  SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
+    for (var i = 0, len = this.children.length; i < len; i++) {
+      if (this.children[i][isSourceNode]) {
+        this.children[i].walkSourceContents(aFn);
+      }
+    }
+    var sources = Object.keys(this.sourceContents);
+    for (var i = 0, len = sources.length; i < len; i++) {
+      aFn(util2.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+    }
+  };
+  SourceNode.prototype.toString = function SourceNode_toString() {
+    var str = "";
+    this.walk(function(chunk) {
+      str += chunk;
+    });
+    return str;
+  };
+  SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+    var generated = {
+      code: "",
+      line: 1,
+      column: 0
+    };
+    var map = new SourceMapGenerator(aArgs);
+    var sourceMappingActive = false;
+    var lastOriginalSource = null;
+    var lastOriginalLine = null;
+    var lastOriginalColumn = null;
+    var lastOriginalName = null;
+    this.walk(function(chunk, original) {
+      generated.code += chunk;
+      if (original.source !== null && original.line !== null && original.column !== null) {
+        if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
+          map.addMapping({
+            source: original.source,
+            original: {
+              line: original.line,
+              column: original.column
+            },
+            generated: {
+              line: generated.line,
+              column: generated.column
+            },
+            name: original.name
+          });
+        }
+        lastOriginalSource = original.source;
+        lastOriginalLine = original.line;
+        lastOriginalColumn = original.column;
+        lastOriginalName = original.name;
+        sourceMappingActive = true;
+      } else if (sourceMappingActive) {
+        map.addMapping({
+          generated: {
+            line: generated.line,
+            column: generated.column
+          }
+        });
+        lastOriginalSource = null;
+        sourceMappingActive = false;
+      }
+      for (var idx = 0, length = chunk.length; idx < length; idx++) {
+        if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+          generated.line++;
+          generated.column = 0;
+          if (idx + 1 === length) {
+            lastOriginalSource = null;
+            sourceMappingActive = false;
+          } else if (sourceMappingActive) {
+            map.addMapping({
+              source: original.source,
+              original: {
+                line: original.line,
+                column: original.column
+              },
+              generated: {
+                line: generated.line,
+                column: generated.column
+              },
+              name: original.name
+            });
+          }
+        } else {
+          generated.column++;
+        }
+      }
+    });
+    this.walkSourceContents(function(sourceFile, sourceContent) {
+      map.setSourceContent(sourceFile, sourceContent);
+    });
+    return { code: generated.code, map };
+  };
+  sourceNode.SourceNode = SourceNode;
+  return sourceNode;
+}
+var hasRequiredSourceMap;
+function requireSourceMap() {
+  if (hasRequiredSourceMap) return sourceMap;
+  hasRequiredSourceMap = 1;
+  sourceMap.SourceMapGenerator = requireSourceMapGenerator().SourceMapGenerator;
+  sourceMap.SourceMapConsumer = requireSourceMapConsumer().SourceMapConsumer;
+  sourceMap.SourceNode = requireSourceNode().SourceNode;
+  return sourceMap;
+}
+var sourceMapExports = requireSourceMap();
+const toLocationCursor = (location) => {
+  return `${location.fileName}:${location.lineNumber}:${location.columnNumber}`;
+};
+const isSameLocation = (left, right) => {
+  return left.fileName === right.fileName && left.lineNumber === right.lineNumber && left.columnNumber === right.columnNumber;
+};
+const resolveOriginalLocation = (rawSourceMap, position) => {
+  const consumer = new sourceMapExports.SourceMapConsumer(rawSourceMap);
+  try {
+    const attempts = [
+      { line: position.line, column: position.column, bias: sourceMapExports.SourceMapConsumer.GREATEST_LOWER_BOUND },
+      { line: position.line, column: 0, bias: sourceMapExports.SourceMapConsumer.GREATEST_LOWER_BOUND },
+      { line: position.line, column: position.column, bias: sourceMapExports.SourceMapConsumer.LEAST_UPPER_BOUND },
+      { line: position.line, column: 0, bias: sourceMapExports.SourceMapConsumer.LEAST_UPPER_BOUND }
+    ];
+    for (const attempt of attempts) {
+      const found = consumer.originalPositionFor(attempt);
+      if (found.source && found.line != null && found.column != null) {
+        return {
+          fileName: found.source,
+          lineNumber: found.line,
+          columnNumber: found.column
+        };
+      }
+    }
+  } finally {
+    const maybeDestroy = consumer.destroy;
+    maybeDestroy?.();
+  }
+  return null;
+};
+const resolveHopFromRecord = (sourceMapRecord, input) => {
+  try {
+    const { lineNumber: line, columnNumber: column } = input;
+    const output = resolveOriginalLocation(sourceMapRecord.rawSourceMap, { line, column });
+    if (!output) return null;
+    return { input, output, mapFileName: sourceMapRecord.mapFileName };
+  } catch {
+    return null;
+  }
+};
+const appendUnresolvedHop = (input) => {
+  const { traceHops, input: location, mapFileName } = input;
+  traceHops.push({ input: location, mapFileName });
+};
+const resolveTraceWithOrderedMaps = (input) => {
+  const { entry, sourceMaps, orderedMapFileNames, maxDepth } = input;
+  const traceHops = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = entry;
+  for (let depth = 0; depth < orderedMapFileNames.length && depth < maxDepth; depth++) {
+    const mapFileName = orderedMapFileNames[depth];
+    const cursor = toLocationCursor(current);
+    if (visited.has(cursor)) {
+      appendUnresolvedHop({ traceHops, input: current, mapFileName });
+      continue;
+    }
+    visited.add(cursor);
+    const sourceMapRecord = getSourceMapByMapFileName(sourceMaps, mapFileName);
+    if (!sourceMapRecord) {
+      appendUnresolvedHop({ traceHops, input: current, mapFileName });
+      continue;
+    }
+    const hop = resolveHopFromRecord(sourceMapRecord, current);
+    if (!hop) {
+      appendUnresolvedHop({ traceHops, input: current, mapFileName: sourceMapRecord.mapFileName });
+      continue;
+    }
+    traceHops.push(hop);
+    current = hop.output;
+  }
+  return traceHops;
+};
+const resolveTraceByFileLookup = (input) => {
+  const { entry, sourceMaps, maxDepth } = input;
+  const traceHops = [];
+  const visited = /* @__PURE__ */ new Set();
+  let current = entry;
+  for (let depth = 0; depth < maxDepth; depth++) {
+    const cursor = toLocationCursor(current);
+    if (visited.has(cursor)) {
+      appendUnresolvedHop({ traceHops, input: current });
+      break;
+    }
+    visited.add(cursor);
+    const sourceMapRecord = getSourceMapByFileName(sourceMaps, current.fileName);
+    if (!sourceMapRecord) {
+      if (traceHops.length === 0) appendUnresolvedHop({ traceHops, input: current });
+      break;
+    }
+    const hop = resolveHopFromRecord(sourceMapRecord, current);
+    if (!hop) {
+      appendUnresolvedHop({ traceHops, input: current, mapFileName: sourceMapRecord.mapFileName });
+      break;
+    }
+    traceHops.push(hop);
+    if (isSameLocation(hop.output, current)) break;
+    current = hop.output;
+  }
+  return traceHops;
+};
+const resolveTraceBySourceMaps = async (input) => {
+  const { entry, sourceMaps, orderedMapFileNames = [], options = {} } = input;
+  const maxDepth = options.maxDepth ?? MAX_TRACE_DEPTH;
+  if (orderedMapFileNames.length > 0) return resolveTraceWithOrderedMaps({ entry, sourceMaps, orderedMapFileNames, maxDepth });
+  return resolveTraceByFileLookup({ entry, sourceMaps, maxDepth });
+};
+const DEFAULT_CONTEXT_LINE_RADIUS = 3;
+const validateResolveInput = (config) => {
+  const parsedLine = Number(config.entryLine);
+  const parsedColumn = Number(config.entryColumn);
+  const parsedContextLineRadius = Number(config.contextLineRadius);
+  const normalizedFileName = config.entryFileName.replace(/\\/g, "/").trim();
+  if (!normalizedFileName) {
+    return { ok: false, message: "请输入入口文件名，例如 index.js" };
+  }
+  if (!config.entryLine.trim()) {
+    return { ok: false, message: "请输入入口行号（1-based）。" };
+  }
+  if (!config.entryColumn.trim()) {
+    return { ok: false, message: "请输入入口列号（0-based）。" };
+  }
+  if (!Number.isInteger(parsedLine) || parsedLine < 1) {
+    return { ok: false, message: "行号必须是大于等于 1 的整数。" };
+  }
+  if (!Number.isInteger(parsedColumn) || parsedColumn < 0) {
+    return { ok: false, message: "列号必须是大于等于 0 的整数。" };
+  }
+  if (!Number.isInteger(parsedContextLineRadius) || parsedContextLineRadius < 0) {
+    return { ok: false, message: "上下文行数必须是大于等于 0 的整数。" };
+  }
+  if (config.mapCount === 0) {
+    return { ok: false, message: "未加载可用 map 文件，请先上传。" };
+  }
+  return {
+    ok: true,
+    entry: {
+      fileName: normalizedFileName,
+      lineNumber: parsedLine,
+      columnNumber: parsedColumn
+    },
+    contextLineRadius: parsedContextLineRadius
+  };
+};
+const buildChainStateFromSlots = (slots) => {
+  const { registry, orderedMapFileNames } = buildRegistryFromChainSlots(slots);
+  return {
+    sourceMaps: registry,
+    sourceMapFileNames: orderedMapFileNames,
+    chainMapSlots: slots,
+    entryFileName: getAutoEntryFileNameFromSlots(slots)
+  };
+};
+const resolveTraceContextTask = async (context) => {
+  const traceChain = await resolveTraceBySourceMaps({
+    entry: context.entry,
+    sourceMaps: context.sourceMaps,
+    orderedMapFileNames: context.sourceMapFileNames,
+    options: { maxDepth: MAX_TRACE_DEPTH }
+  });
+  const sourceCode = resolveSourceCodeFromTrace(traceChain, context.sourceMaps, {
+    onlyLastMap: true,
+    lastMapFileName: context.sourceMapFileNames[context.sourceMapFileNames.length - 1]
+  });
+  return {
+    traceChain,
+    sourceCode,
+    lastResolved: getLastResolvedOutput(traceChain)
+  };
+};
+const buildTraceMetaOutput = (resolved) => {
+  if (resolved.sourceCode) {
+    return {
+      traceData: resolved.traceChain,
+      resolvedSourceMeta: {
+        sourceFile: resolved.sourceCode.sourceFile,
+        lineNumber: resolved.sourceCode.lineNumber,
+        columnNumber: resolved.sourceCode.columnNumber
+      },
+      canFetchSourceSnippet: true,
+      message: "已定位到源码位置，开始加载源码片段。"
+    };
+  }
+  if (resolved.lastResolved) {
+    const display = toDisplayLocation(resolved.lastResolved);
+    return {
+      traceData: resolved.traceChain,
+      resolvedSourceMeta: {
+        sourceFile: display.fileName,
+        lineNumber: display.lineNumber,
+        columnNumber: display.columnNumber
+      },
+      canFetchSourceSnippet: false,
+      message: "当前 map 不包含 sourcesContent，无法直接渲染源码内容。"
+    };
+  }
+  return {
+    traceData: resolved.traceChain,
+    resolvedSourceMeta: null,
+    canFetchSourceSnippet: false,
+    message: "未命中映射，未定位到源码位置。"
+  };
+};
+const buildTraceSnippetOutput = (input) => {
+  const { contextLineRadius, resolved } = input;
+  if (resolved.sourceCode) {
+    const excerpt = createCodeExcerpt({
+      fullCode: resolved.sourceCode.code,
+      targetLine: resolved.sourceCode.lineNumber,
+      radius: contextLineRadius,
+      targetColumn: resolved.sourceCode.columnNumber
+    });
+    return {
+      traceCode: excerpt.code,
+      resolvedSourceMeta: {
+        sourceFile: resolved.sourceCode.sourceFile,
+        lineNumber: resolved.sourceCode.lineNumber,
+        columnNumber: resolved.sourceCode.columnNumber
+      },
+      traceHighlightLines: [excerpt.highlightLine]
+    };
+  }
+  if (resolved.lastResolved) {
+    const display = toDisplayLocation(resolved.lastResolved);
+    return {
+      traceCode: [
+        `已定位到源码位置：${display.fileName}:${display.lineNumber}:${display.columnNumber}`,
+        "当前 map 不包含 sourcesContent，无法直接渲染源码内容。"
+      ].join("\n"),
+      resolvedSourceMeta: {
+        sourceFile: display.fileName,
+        lineNumber: display.lineNumber,
+        columnNumber: display.columnNumber
+      },
+      traceHighlightLines: []
+    };
+  }
+  return {
+    traceCode: "未命中映射，未定位到源码位置。",
+    resolvedSourceMeta: null,
+    traceHighlightLines: []
+  };
+};
+const createChainSlotFromPath = async (filePath) => {
+  const resolvedPath = filePath.startsWith("~/") ? `${node_os.homedir()}/${filePath.slice(2)}` : filePath;
+  const mapFileName = node_path.basename(resolvedPath);
+  const slotId = `${mapFileName}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    const fileText = await promises.readFile(resolvedPath, "utf8");
+    const rawSourceMap = JSON.parse(fileText);
+    if (!rawSourceMap || typeof rawSourceMap !== "object" || typeof rawSourceMap.mappings !== "string") {
+      throw new Error("invalid source-map json");
+    }
+    return {
+      id: slotId,
+      mapFileName,
+      mapFilePath: resolvedPath,
+      sourceMapRecord: { rawSourceMap, mapFileName }
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "unknown error";
+    return {
+      id: slotId,
+      mapFileName,
+      mapFilePath: resolvedPath,
+      error: `${mapFileName}: ${message}`
+    };
+  }
+};
+const createResolveContext = async (parsed) => {
+  const chainSlots = await Promise.all(parsed.mapFilePaths.map(createChainSlotFromPath));
+  const chainState = buildChainStateFromSlots(chainSlots);
+  const validated = validateResolveInput({
+    entryFileName: parsed.entryFileName,
+    entryLine: parsed.entryLine,
+    entryColumn: parsed.entryColumn,
+    contextLineRadius: parsed.contextLineRadius || String(DEFAULT_CONTEXT_LINE_RADIUS),
+    mapCount: chainState.sourceMapFileNames.length
+  });
+  if (!validated.ok) throw new Error(validated.message);
+  return {
+    entry: validated.entry,
+    contextLineRadius: validated.contextLineRadius,
+    sourceMaps: chainState.sourceMaps,
+    sourceMapFileNames: chainState.sourceMapFileNames
+  };
+};
+const INPUT_VALIDATION_PATTERNS = ["请输入", "必须是", "未加载"];
+const parseResolveInput = (payloadText) => {
+  const parsed = JSON.parse(payloadText);
+  if (!parsed || typeof parsed !== "object") throw new Error("invalid resolveTrace payload");
+  if (!parsed.entryFileName) throw new Error("missing argument: entryFileName");
+  if (!parsed.entryLine) throw new Error("missing argument: entryLine");
+  if (!parsed.entryColumn) throw new Error("missing argument: entryColumn");
+  if (!Array.isArray(parsed.mapFilePaths) || parsed.mapFilePaths.length === 0) {
+    throw new Error("missing argument: mapFilePaths");
+  }
+  return {
+    ...parsed,
+    contextLineRadius: parsed.contextLineRadius || String(DEFAULT_CONTEXT_LINE_RADIUS)
+  };
+};
+const isInputValidationMessage = (message) => INPUT_VALIDATION_PATTERNS.some((pattern) => message.includes(pattern));
+const toFallbackEntry = (parsed) => ({
+  fileName: parsed.entryFileName,
+  lineNumber: Number(parsed.entryLine) || 1,
+  columnNumber: Number(parsed.entryColumn) || 0
+});
+const createValidationMetaOutput = (message) => ({
+  traceData: [],
+  resolvedSourceMeta: null,
+  canFetchSourceSnippet: false,
+  message
+});
+const DEFAULT_MAX_SNIPPET_PAYLOAD_BYTES = 32 * 1024;
+const SNIPPET_PAYLOAD_EXCEEDED_ERROR = "SOURCE_SNIPPET_PAYLOAD_EXCEEDED: 返回体超出限制";
+const SNIPPET_PAYLOAD_OVERHEAD_BYTES = 512;
+const parseMaxSnippetPayloadBytes = (input) => {
+  if (!input.maxSnippetPayloadBytes?.trim()) return DEFAULT_MAX_SNIPPET_PAYLOAD_BYTES;
+  const parsed = Number(input.maxSnippetPayloadBytes);
+  if (!Number.isInteger(parsed) || parsed <= 0) throw new Error("maxSnippetPayloadBytes 必须是大于 0 的整数。");
+  return parsed;
+};
+const estimateSnippetPayloadBytes = (snippet) => {
+  const codeBytes = Buffer.byteLength(snippet.traceCode, "utf8");
+  const sourceFileBytes = snippet.resolvedSourceMeta?.sourceFile ? Buffer.byteLength(snippet.resolvedSourceMeta.sourceFile, "utf8") : 0;
+  const highlightBytes = snippet.traceHighlightLines.reduce((total, line) => {
+    return total + Buffer.byteLength(String(line), "utf8") + 1;
+  }, 0);
+  return codeBytes + sourceFileBytes + highlightBytes + SNIPPET_PAYLOAD_OVERHEAD_BYTES;
+};
+const assertSnippetPayloadWithinLimit = (snippet, input) => {
+  const maxSnippetPayloadBytes = parseMaxSnippetPayloadBytes(input);
+  const payloadBytes = estimateSnippetPayloadBytes(snippet);
+  if (payloadBytes > maxSnippetPayloadBytes) throw new Error(
+    `${SNIPPET_PAYLOAD_EXCEEDED_ERROR} (${payloadBytes} bytes > ${maxSnippetPayloadBytes} bytes)`
+  );
+};
+const pushProfilePhase = (phases, name, startedAt) => {
+  phases.push({ name, durationMs: Number((node_perf_hooks.performance.now() - startedAt).toFixed(2)) });
+};
+const resolveTrace = async (payloadText) => {
+  const parsed = parseResolveInput(payloadText);
+  try {
+    const resolveContext = await createResolveContext(parsed);
+    const resolved = await resolveTraceContextTask(resolveContext);
+    return buildTraceMetaOutput(resolved);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "unknown error";
+    if (isInputValidationMessage(message)) return createValidationMetaOutput(message);
+    return {
+      traceData: [{ input: toFallbackEntry(parsed) }],
+      resolvedSourceMeta: null,
+      canFetchSourceSnippet: false,
+      message: `source-map trace failed: ${message}`
+    };
+  }
+};
+const getSourceSnippet = async (payloadText) => {
+  const parsed = parseResolveInput(payloadText);
+  const resolveContext = await createResolveContext(parsed);
+  const resolved = await resolveTraceContextTask(resolveContext);
+  const snippetOutput = buildTraceSnippetOutput({
+    contextLineRadius: resolveContext.contextLineRadius,
+    resolved
+  });
+  assertSnippetPayloadWithinLimit(snippetOutput, parsed);
+  return snippetOutput;
+};
+const profileResolveTracePhases = async (payloadText) => {
+  const phases = [];
+  const totalStart = node_perf_hooks.performance.now();
+  const parseStart = node_perf_hooks.performance.now();
+  const parsed = parseResolveInput(payloadText);
+  pushProfilePhase(phases, "parseResolveInput", parseStart);
+  const createContextStart = node_perf_hooks.performance.now();
+  const resolveContext = await createResolveContext(parsed);
+  pushProfilePhase(phases, "createResolveContext", createContextStart);
+  const resolveTraceStart = node_perf_hooks.performance.now();
+  const resolved = await resolveTraceContextTask(resolveContext);
+  pushProfilePhase(phases, "resolveTraceContextTask", resolveTraceStart);
+  const buildMetaStart = node_perf_hooks.performance.now();
+  const metaOutput = buildTraceMetaOutput(resolved);
+  pushProfilePhase(phases, "buildTraceMetaOutput", buildMetaStart);
+  const buildSnippetStart = node_perf_hooks.performance.now();
+  const snippetOutput = buildTraceSnippetOutput({
+    contextLineRadius: resolveContext.contextLineRadius,
+    resolved
+  });
+  pushProfilePhase(phases, "buildTraceSnippetOutput", buildSnippetStart);
+  const estimateStart = node_perf_hooks.performance.now();
+  const maxSnippetPayloadBytes = parseMaxSnippetPayloadBytes(parsed);
+  const snippetPayloadBytes = estimateSnippetPayloadBytes(snippetOutput);
+  pushProfilePhase(phases, "estimateSnippetPayloadBytes", estimateStart);
+  return {
+    phases,
+    totalMs: Number((node_perf_hooks.performance.now() - totalStart).toFixed(2)),
+    traceHopCount: metaOutput.traceData.length,
+    resolvedSourceMetaExists: Boolean(metaOutput.resolvedSourceMeta),
+    snippetPayloadBytes,
+    maxSnippetPayloadBytes,
+    snippetPayloadWouldExceedLimit: snippetPayloadBytes > maxSnippetPayloadBytes
+  };
+};
+const invokeMethod = defineInvokeMethod({ resolveTrace, getSourceSnippet, profileResolveTracePhases });
+registerInvokeMethod(invokeMethod);