(() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __defProps = Object.defineProperties;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __propIsEnum = Object.prototype.propertyIsEnumerable;
  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __spreadValues = (a, b) => {
    for (var prop in b || (b = {}))
      if (__hasOwnProp.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    if (__getOwnPropSymbols)
      for (var prop of __getOwnPropSymbols(b)) {
        if (__propIsEnum.call(b, prop))
          __defNormalProp(a, prop, b[prop]);
      }
    return a;
  };
  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
  var __commonJS = (cb, mod) => function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __reExport = (target, module, copyDefault, desc) => {
    if (module && typeof module === "object" || typeof module === "function") {
      for (let key of __getOwnPropNames(module))
        if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
    }
    return target;
  };
  var __toESM = (module, isNodeMode) => {
    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", !isNodeMode && module && module.__esModule ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
  };

  // node_modules/stackframe/stackframe.js
  var require_stackframe = __commonJS({
    "node_modules/stackframe/stackframe.js"(exports, module) {
      (function(root, factory) {
        "use strict";
        if (typeof define === "function" && define.amd) {
          define("stackframe", [], factory);
        } else if (typeof exports === "object") {
          module.exports = factory();
        } else {
          root.StackFrame = factory();
        }
      })(exports, function() {
        "use strict";
        function _isNumber(n) {
          return !isNaN(parseFloat(n)) && isFinite(n);
        }
        __name(_isNumber, "_isNumber");
        function _capitalize(str) {
          return str.charAt(0).toUpperCase() + str.substring(1);
        }
        __name(_capitalize, "_capitalize");
        function _getter(p) {
          return function() {
            return this[p];
          };
        }
        __name(_getter, "_getter");
        var booleanProps = ["isConstructor", "isEval", "isNative", "isToplevel"];
        var numericProps = ["columnNumber", "lineNumber"];
        var stringProps = ["fileName", "functionName", "source"];
        var arrayProps = ["args"];
        var objectProps = ["evalOrigin"];
        var props = booleanProps.concat(numericProps, stringProps, arrayProps, objectProps);
        function StackFrame(obj) {
          if (!obj)
            return;
          for (var i2 = 0; i2 < props.length; i2++) {
            if (obj[props[i2]] !== void 0) {
              this["set" + _capitalize(props[i2])](obj[props[i2]]);
            }
          }
        }
        __name(StackFrame, "StackFrame");
        StackFrame.prototype = {
          getArgs: function() {
            return this.args;
          },
          setArgs: function(v) {
            if (Object.prototype.toString.call(v) !== "[object Array]") {
              throw new TypeError("Args must be an Array");
            }
            this.args = v;
          },
          getEvalOrigin: function() {
            return this.evalOrigin;
          },
          setEvalOrigin: function(v) {
            if (v instanceof StackFrame) {
              this.evalOrigin = v;
            } else if (v instanceof Object) {
              this.evalOrigin = new StackFrame(v);
            } else {
              throw new TypeError("Eval Origin must be an Object or StackFrame");
            }
          },
          toString: function() {
            var fileName = this.getFileName() || "";
            var lineNumber = this.getLineNumber() || "";
            var columnNumber = this.getColumnNumber() || "";
            var functionName = this.getFunctionName() || "";
            if (this.getIsEval()) {
              if (fileName) {
                return "[eval] (" + fileName + ":" + lineNumber + ":" + columnNumber + ")";
              }
              return "[eval]:" + lineNumber + ":" + columnNumber;
            }
            if (functionName) {
              return functionName + " (" + fileName + ":" + lineNumber + ":" + columnNumber + ")";
            }
            return fileName + ":" + lineNumber + ":" + columnNumber;
          }
        };
        StackFrame.fromString = /* @__PURE__ */ __name(function StackFrame$$fromString(str) {
          var argsStartIndex = str.indexOf("(");
          var argsEndIndex = str.lastIndexOf(")");
          var functionName = str.substring(0, argsStartIndex);
          var args = str.substring(argsStartIndex + 1, argsEndIndex).split(",");
          var locationString = str.substring(argsEndIndex + 1);
          if (locationString.indexOf("@") === 0) {
            var parts = /@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(locationString, "");
            var fileName = parts[1];
            var lineNumber = parts[2];
            var columnNumber = parts[3];
          }
          return new StackFrame({
            functionName,
            args: args || void 0,
            fileName,
            lineNumber: lineNumber || void 0,
            columnNumber: columnNumber || void 0
          });
        }, "StackFrame$$fromString");
        for (var i = 0; i < booleanProps.length; i++) {
          StackFrame.prototype["get" + _capitalize(booleanProps[i])] = _getter(booleanProps[i]);
          StackFrame.prototype["set" + _capitalize(booleanProps[i])] = function(p) {
            return function(v) {
              this[p] = Boolean(v);
            };
          }(booleanProps[i]);
        }
        for (var j = 0; j < numericProps.length; j++) {
          StackFrame.prototype["get" + _capitalize(numericProps[j])] = _getter(numericProps[j]);
          StackFrame.prototype["set" + _capitalize(numericProps[j])] = function(p) {
            return function(v) {
              if (!_isNumber(v)) {
                throw new TypeError(p + " must be a Number");
              }
              this[p] = Number(v);
            };
          }(numericProps[j]);
        }
        for (var k = 0; k < stringProps.length; k++) {
          StackFrame.prototype["get" + _capitalize(stringProps[k])] = _getter(stringProps[k]);
          StackFrame.prototype["set" + _capitalize(stringProps[k])] = function(p) {
            return function(v) {
              this[p] = String(v);
            };
          }(stringProps[k]);
        }
        return StackFrame;
      });
    }
  });

  // node_modules/error-stack-parser/error-stack-parser.js
  var require_error_stack_parser = __commonJS({
    "node_modules/error-stack-parser/error-stack-parser.js"(exports, module) {
      (function(root, factory) {
        "use strict";
        if (typeof define === "function" && define.amd) {
          define("error-stack-parser", ["stackframe"], factory);
        } else if (typeof exports === "object") {
          module.exports = factory(require_stackframe());
        } else {
          root.ErrorStackParser = factory(root.StackFrame);
        }
      })(exports, /* @__PURE__ */ __name(function ErrorStackParser(StackFrame) {
        "use strict";
        var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
        var CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
        var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code])?$/;
        return {
          parse: /* @__PURE__ */ __name(function ErrorStackParser$$parse(error) {
            if (typeof error.stacktrace !== "undefined" || typeof error["opera#sourceloc"] !== "undefined") {
              return this.parseOpera(error);
            } else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP)) {
              return this.parseV8OrIE(error);
            } else if (error.stack) {
              return this.parseFFOrSafari(error);
            } else {
              throw new Error("Cannot parse given Error object");
            }
          }, "ErrorStackParser$$parse"),
          extractLocation: /* @__PURE__ */ __name(function ErrorStackParser$$extractLocation(urlLike) {
            if (urlLike.indexOf(":") === -1) {
              return [urlLike];
            }
            var regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
            var parts = regExp.exec(urlLike.replace(/[()]/g, ""));
            return [parts[1], parts[2] || void 0, parts[3] || void 0];
          }, "ErrorStackParser$$extractLocation"),
          parseV8OrIE: /* @__PURE__ */ __name(function ErrorStackParser$$parseV8OrIE(error) {
            var filtered = error.stack.split("\n").filter(function(line) {
              return !!line.match(CHROME_IE_STACK_REGEXP);
            }, this);
            return filtered.map(function(line) {
              if (line.indexOf("(eval ") > -1) {
                line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(\),.*$)/g, "");
              }
              var sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(");
              var location2 = sanitizedLine.match(/ (\((.+):(\d+):(\d+)\)$)/);
              sanitizedLine = location2 ? sanitizedLine.replace(location2[0], "") : sanitizedLine;
              var tokens = sanitizedLine.split(/\s+/).slice(1);
              var locationParts = this.extractLocation(location2 ? location2[1] : tokens.pop());
              var functionName = tokens.join(" ") || void 0;
              var fileName = ["eval", "<anonymous>"].indexOf(locationParts[0]) > -1 ? void 0 : locationParts[0];
              return new StackFrame({
                functionName,
                fileName,
                lineNumber: locationParts[1],
                columnNumber: locationParts[2],
                source: line
              });
            }, this);
          }, "ErrorStackParser$$parseV8OrIE"),
          parseFFOrSafari: /* @__PURE__ */ __name(function ErrorStackParser$$parseFFOrSafari(error) {
            var filtered = error.stack.split("\n").filter(function(line) {
              return !line.match(SAFARI_NATIVE_CODE_REGEXP);
            }, this);
            return filtered.map(function(line) {
              if (line.indexOf(" > eval") > -1) {
                line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
              }
              if (line.indexOf("@") === -1 && line.indexOf(":") === -1) {
                return new StackFrame({
                  functionName: line
                });
              } else {
                var functionNameRegex = /((.*".+"[^@]*)?[^@]*)(?:@)/;
                var matches = line.match(functionNameRegex);
                var functionName = matches && matches[1] ? matches[1] : void 0;
                var locationParts = this.extractLocation(line.replace(functionNameRegex, ""));
                return new StackFrame({
                  functionName,
                  fileName: locationParts[0],
                  lineNumber: locationParts[1],
                  columnNumber: locationParts[2],
                  source: line
                });
              }
            }, this);
          }, "ErrorStackParser$$parseFFOrSafari"),
          parseOpera: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera(e) {
            if (!e.stacktrace || e.message.indexOf("\n") > -1 && e.message.split("\n").length > e.stacktrace.split("\n").length) {
              return this.parseOpera9(e);
            } else if (!e.stack) {
              return this.parseOpera10(e);
            } else {
              return this.parseOpera11(e);
            }
          }, "ErrorStackParser$$parseOpera"),
          parseOpera9: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera9(e) {
            var lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
            var lines = e.message.split("\n");
            var result = [];
            for (var i = 2, len = lines.length; i < len; i += 2) {
              var match = lineRE.exec(lines[i]);
              if (match) {
                result.push(new StackFrame({
                  fileName: match[2],
                  lineNumber: match[1],
                  source: lines[i]
                }));
              }
            }
            return result;
          }, "ErrorStackParser$$parseOpera9"),
          parseOpera10: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera10(e) {
            var lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
            var lines = e.stacktrace.split("\n");
            var result = [];
            for (var i = 0, len = lines.length; i < len; i += 2) {
              var match = lineRE.exec(lines[i]);
              if (match) {
                result.push(new StackFrame({
                  functionName: match[3] || void 0,
                  fileName: match[2],
                  lineNumber: match[1],
                  source: lines[i]
                }));
              }
            }
            return result;
          }, "ErrorStackParser$$parseOpera10"),
          parseOpera11: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera11(error) {
            var filtered = error.stack.split("\n").filter(function(line) {
              return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);
            }, this);
            return filtered.map(function(line) {
              var tokens = line.split("@");
              var locationParts = this.extractLocation(tokens.pop());
              var functionCall = tokens.shift() || "";
              var functionName = functionCall.replace(/<anonymous function(: (\w+))?>/, "$2").replace(/\([^)]*\)/g, "") || void 0;
              var argsRaw;
              if (functionCall.match(/\(([^)]*)\)/)) {
                argsRaw = functionCall.replace(/^[^(]+\(([^)]*)\)$/, "$1");
              }
              var args = argsRaw === void 0 || argsRaw === "[arguments not available]" ? void 0 : argsRaw.split(",");
              return new StackFrame({
                functionName,
                args,
                fileName: locationParts[0],
                lineNumber: locationParts[1],
                columnNumber: locationParts[2],
                source: line
              });
            }, this);
          }, "ErrorStackParser$$parseOpera11")
        };
      }, "ErrorStackParser"));
    }
  });

  // node_modules/stack-generator/stack-generator.js
  var require_stack_generator = __commonJS({
    "node_modules/stack-generator/stack-generator.js"(exports, module) {
      (function(root, factory) {
        "use strict";
        if (typeof define === "function" && define.amd) {
          define("stack-generator", ["stackframe"], factory);
        } else if (typeof exports === "object") {
          module.exports = factory(require_stackframe());
        } else {
          root.StackGenerator = factory(root.StackFrame);
        }
      })(exports, function(StackFrame) {
        return {
          backtrace: /* @__PURE__ */ __name(function StackGenerator$$backtrace(opts) {
            var stack = [];
            var maxStackSize = 10;
            if (typeof opts === "object" && typeof opts.maxStackSize === "number") {
              maxStackSize = opts.maxStackSize;
            }
            var curr = arguments.callee;
            while (curr && stack.length < maxStackSize && curr["arguments"]) {
              var args = new Array(curr["arguments"].length);
              for (var i = 0; i < args.length; ++i) {
                args[i] = curr["arguments"][i];
              }
              if (/function(?:\s+([\w$]+))+\s*\(/.test(curr.toString())) {
                stack.push(new StackFrame({ functionName: RegExp.$1 || void 0, args }));
              } else {
                stack.push(new StackFrame({ args }));
              }
              try {
                curr = curr.caller;
              } catch (e) {
                break;
              }
            }
            return stack;
          }, "StackGenerator$$backtrace")
        };
      });
    }
  });

  // node_modules/source-map/lib/util.js
  var require_util = __commonJS({
    "node_modules/source-map/lib/util.js"(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.');
        }
      }
      __name(getArg, "getArg");
      exports.getArg = getArg;
      var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
      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]
        };
      }
      __name(urlParse, "urlParse");
      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;
      }
      __name(urlGenerate, "urlGenerate");
      exports.urlGenerate = urlGenerate;
      function normalize(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 = path.split(/\/+/);
        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;
      }
      __name(normalize, "normalize");
      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;
      }
      __name(join, "join");
      exports.join = join;
      exports.isAbsolute = function(aPath) {
        return aPath.charAt(0) === "/" || !!aPath.match(urlRegexp);
      };
      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);
      }
      __name(relative, "relative");
      exports.relative = relative;
      var supportsNullProto = function() {
        var obj = /* @__PURE__ */ Object.create(null);
        return !("__proto__" in obj);
      }();
      function identity(s) {
        return s;
      }
      __name(identity, "identity");
      function toSetString(aStr) {
        if (isProtoString(aStr)) {
          return "$" + aStr;
        }
        return aStr;
      }
      __name(toSetString, "toSetString");
      exports.toSetString = supportsNullProto ? identity : toSetString;
      function fromSetString(aStr) {
        if (isProtoString(aStr)) {
          return aStr.slice(1);
        }
        return aStr;
      }
      __name(fromSetString, "fromSetString");
      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;
      }
      __name(isProtoString, "isProtoString");
      function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
        var cmp = 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 mappingA.name - mappingB.name;
      }
      __name(compareByOriginalPositions, "compareByOriginalPositions");
      exports.compareByOriginalPositions = compareByOriginalPositions;
      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 = 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 mappingA.name - mappingB.name;
      }
      __name(compareByGeneratedPositionsDeflated, "compareByGeneratedPositionsDeflated");
      exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
      function strcmp(aStr1, aStr2) {
        if (aStr1 === aStr2) {
          return 0;
        }
        if (aStr1 > aStr2) {
          return 1;
        }
        return -1;
      }
      __name(strcmp, "strcmp");
      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);
      }
      __name(compareByGeneratedPositionsInflated, "compareByGeneratedPositionsInflated");
      exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
    }
  });

  // node_modules/source-map/lib/binary-search.js
  var require_binary_search = __commonJS({
    "node_modules/source-map/lib/binary-search.js"(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;
          }
        }
      }
      __name(recursiveSearch, "recursiveSearch");
      exports.search = /* @__PURE__ */ __name(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;
      }, "search");
    }
  });

  // node_modules/source-map/lib/array-set.js
  var require_array_set = __commonJS({
    "node_modules/source-map/lib/array-set.js"(exports) {
      var util = require_util();
      var has = Object.prototype.hasOwnProperty;
      function ArraySet() {
        this._array = [];
        this._set = /* @__PURE__ */ Object.create(null);
      }
      __name(ArraySet, "ArraySet");
      ArraySet.fromArray = /* @__PURE__ */ __name(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_fromArray");
      ArraySet.prototype.size = /* @__PURE__ */ __name(function ArraySet_size() {
        return Object.getOwnPropertyNames(this._set).length;
      }, "ArraySet_size");
      ArraySet.prototype.add = /* @__PURE__ */ __name(function ArraySet_add(aStr, aAllowDuplicates) {
        var sStr = util.toSetString(aStr);
        var isDuplicate = has.call(this._set, sStr);
        var idx = this._array.length;
        if (!isDuplicate || aAllowDuplicates) {
          this._array.push(aStr);
        }
        if (!isDuplicate) {
          this._set[sStr] = idx;
        }
      }, "ArraySet_add");
      ArraySet.prototype.has = /* @__PURE__ */ __name(function ArraySet_has(aStr) {
        var sStr = util.toSetString(aStr);
        return has.call(this._set, sStr);
      }, "ArraySet_has");
      ArraySet.prototype.indexOf = /* @__PURE__ */ __name(function ArraySet_indexOf(aStr) {
        var sStr = util.toSetString(aStr);
        if (has.call(this._set, sStr)) {
          return this._set[sStr];
        }
        throw new Error('"' + aStr + '" is not in the set.');
      }, "ArraySet_indexOf");
      ArraySet.prototype.at = /* @__PURE__ */ __name(function ArraySet_at(aIdx) {
        if (aIdx >= 0 && aIdx < this._array.length) {
          return this._array[aIdx];
        }
        throw new Error("No element indexed by " + aIdx);
      }, "ArraySet_at");
      ArraySet.prototype.toArray = /* @__PURE__ */ __name(function ArraySet_toArray() {
        return this._array.slice();
      }, "ArraySet_toArray");
      exports.ArraySet = ArraySet;
    }
  });

  // node_modules/source-map/lib/base64.js
  var require_base64 = __commonJS({
    "node_modules/source-map/lib/base64.js"(exports) {
      var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
      exports.encode = function(number) {
        if (0 <= number && number < intToCharMap.length) {
          return intToCharMap[number];
        }
        throw new TypeError("Must be between 0 and 63: " + number);
      };
      exports.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;
      };
    }
  });

  // node_modules/source-map/lib/base64-vlq.js
  var require_base64_vlq = __commonJS({
    "node_modules/source-map/lib/base64-vlq.js"(exports) {
      var base64 = require_base64();
      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;
      }
      __name(toVLQSigned, "toVLQSigned");
      function fromVLQSigned(aValue) {
        var isNegative = (aValue & 1) === 1;
        var shifted = aValue >> 1;
        return isNegative ? -shifted : shifted;
      }
      __name(fromVLQSigned, "fromVLQSigned");
      exports.encode = /* @__PURE__ */ __name(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 += base64.encode(digit);
        } while (vlq > 0);
        return encoded;
      }, "base64VLQ_encode");
      exports.decode = /* @__PURE__ */ __name(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 = base64.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;
      }, "base64VLQ_decode");
    }
  });

  // node_modules/source-map/lib/quick-sort.js
  var require_quick_sort = __commonJS({
    "node_modules/source-map/lib/quick-sort.js"(exports) {
      function swap(ary, x, y) {
        var temp = ary[x];
        ary[x] = ary[y];
        ary[y] = temp;
      }
      __name(swap, "swap");
      function randomIntInRange(low, high) {
        return Math.round(low + Math.random() * (high - low));
      }
      __name(randomIntInRange, "randomIntInRange");
      function doQuickSort(ary, comparator, 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 (comparator(ary[j], pivot) <= 0) {
              i += 1;
              swap(ary, i, j);
            }
          }
          swap(ary, i + 1, j);
          var q = i + 1;
          doQuickSort(ary, comparator, p, q - 1);
          doQuickSort(ary, comparator, q + 1, r);
        }
      }
      __name(doQuickSort, "doQuickSort");
      exports.quickSort = function(ary, comparator) {
        doQuickSort(ary, comparator, 0, ary.length - 1);
      };
    }
  });

  // node_modules/source-map/lib/source-map-consumer.js
  var require_source_map_consumer = __commonJS({
    "node_modules/source-map/lib/source-map-consumer.js"(exports) {
      var util = require_util();
      var binarySearch = require_binary_search();
      var ArraySet = require_array_set().ArraySet;
      var base64VLQ = require_base64_vlq();
      var quickSort = require_quick_sort().quickSort;
      function SourceMapConsumer(aSourceMap) {
        var sourceMap = aSourceMap;
        if (typeof aSourceMap === "string") {
          sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ""));
        }
        return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap) : new BasicSourceMapConsumer(sourceMap);
      }
      __name(SourceMapConsumer, "SourceMapConsumer");
      SourceMapConsumer.fromSourceMap = function(aSourceMap) {
        return BasicSourceMapConsumer.fromSourceMap(aSourceMap);
      };
      SourceMapConsumer.prototype._version = 3;
      SourceMapConsumer.prototype.__generatedMappings = null;
      Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
        get: function() {
          if (!this.__generatedMappings) {
            this._parseMappings(this._mappings, this.sourceRoot);
          }
          return this.__generatedMappings;
        }
      });
      SourceMapConsumer.prototype.__originalMappings = null;
      Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
        get: function() {
          if (!this.__originalMappings) {
            this._parseMappings(this._mappings, this.sourceRoot);
          }
          return this.__originalMappings;
        }
      });
      SourceMapConsumer.prototype._charIsMappingSeparator = /* @__PURE__ */ __name(function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
        var c = aStr.charAt(index);
        return c === ";" || c === ",";
      }, "SourceMapConsumer_charIsMappingSeparator");
      SourceMapConsumer.prototype._parseMappings = /* @__PURE__ */ __name(function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
        throw new Error("Subclasses must implement _parseMappings");
      }, "SourceMapConsumer_parseMappings");
      SourceMapConsumer.GENERATED_ORDER = 1;
      SourceMapConsumer.ORIGINAL_ORDER = 2;
      SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
      SourceMapConsumer.LEAST_UPPER_BOUND = 2;
      SourceMapConsumer.prototype.eachMapping = /* @__PURE__ */ __name(function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
        var context = aContext || null;
        var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
        var mappings;
        switch (order) {
          case SourceMapConsumer.GENERATED_ORDER:
            mappings = this._generatedMappings;
            break;
          case SourceMapConsumer.ORIGINAL_ORDER:
            mappings = this._originalMappings;
            break;
          default:
            throw new Error("Unknown order of iteration.");
        }
        var sourceRoot = this.sourceRoot;
        mappings.map(function(mapping) {
          var source = mapping.source === null ? null : this._sources.at(mapping.source);
          if (source != null && sourceRoot != null) {
            source = util.join(sourceRoot, source);
          }
          return {
            source,
            generatedLine: mapping.generatedLine,
            generatedColumn: mapping.generatedColumn,
            originalLine: mapping.originalLine,
            originalColumn: mapping.originalColumn,
            name: mapping.name === null ? null : this._names.at(mapping.name)
          };
        }, this).forEach(aCallback, context);
      }, "SourceMapConsumer_eachMapping");
      SourceMapConsumer.prototype.allGeneratedPositionsFor = /* @__PURE__ */ __name(function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
        var line = util.getArg(aArgs, "line");
        var needle = {
          source: util.getArg(aArgs, "source"),
          originalLine: line,
          originalColumn: util.getArg(aArgs, "column", 0)
        };
        if (this.sourceRoot != null) {
          needle.source = util.relative(this.sourceRoot, needle.source);
        }
        if (!this._sources.has(needle.source)) {
          return [];
        }
        needle.source = this._sources.indexOf(needle.source);
        var mappings = [];
        var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND);
        if (index >= 0) {
          var mapping = this._originalMappings[index];
          if (aArgs.column === void 0) {
            var originalLine = mapping.originalLine;
            while (mapping && mapping.originalLine === originalLine) {
              mappings.push({
                line: util.getArg(mapping, "generatedLine", null),
                column: util.getArg(mapping, "generatedColumn", null),
                lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
              });
              mapping = this._originalMappings[++index];
            }
          } else {
            var originalColumn = mapping.originalColumn;
            while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
              mappings.push({
                line: util.getArg(mapping, "generatedLine", null),
                column: util.getArg(mapping, "generatedColumn", null),
                lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
              });
              mapping = this._originalMappings[++index];
            }
          }
        }
        return mappings;
      }, "SourceMapConsumer_allGeneratedPositionsFor");
      exports.SourceMapConsumer = SourceMapConsumer;
      function BasicSourceMapConsumer(aSourceMap) {
        var sourceMap = aSourceMap;
        if (typeof aSourceMap === "string") {
          sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ""));
        }
        var version = util.getArg(sourceMap, "version");
        var sources = util.getArg(sourceMap, "sources");
        var names = util.getArg(sourceMap, "names", []);
        var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
        var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
        var mappings = util.getArg(sourceMap, "mappings");
        var file = util.getArg(sourceMap, "file", null);
        if (version != this._version) {
          throw new Error("Unsupported version: " + version);
        }
        sources = sources.map(String).map(util.normalize).map(function(source) {
          return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
        });
        this._names = ArraySet.fromArray(names.map(String), true);
        this._sources = ArraySet.fromArray(sources, true);
        this.sourceRoot = sourceRoot;
        this.sourcesContent = sourcesContent;
        this._mappings = mappings;
        this.file = file;
      }
      __name(BasicSourceMapConsumer, "BasicSourceMapConsumer");
      BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
      BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
      BasicSourceMapConsumer.fromSourceMap = /* @__PURE__ */ __name(function SourceMapConsumer_fromSourceMap(aSourceMap) {
        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;
        var generatedMappings = aSourceMap._mappings.toArray().slice();
        var destGeneratedMappings = smc.__generatedMappings = [];
        var destOriginalMappings = smc.__originalMappings = [];
        for (var i = 0, length = generatedMappings.length; i < length; i++) {
          var srcMapping = generatedMappings[i];
          var destMapping = new Mapping();
          destMapping.generatedLine = srcMapping.generatedLine;
          destMapping.generatedColumn = srcMapping.generatedColumn;
          if (srcMapping.source) {
            destMapping.source = sources.indexOf(srcMapping.source);
            destMapping.originalLine = srcMapping.originalLine;
            destMapping.originalColumn = srcMapping.originalColumn;
            if (srcMapping.name) {
              destMapping.name = names.indexOf(srcMapping.name);
            }
            destOriginalMappings.push(destMapping);
          }
          destGeneratedMappings.push(destMapping);
        }
        quickSort(smc.__originalMappings, util.compareByOriginalPositions);
        return smc;
      }, "SourceMapConsumer_fromSourceMap");
      BasicSourceMapConsumer.prototype._version = 3;
      Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", {
        get: function() {
          return this._sources.toArray().map(function(s) {
            return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
          }, this);
        }
      });
      function Mapping() {
        this.generatedLine = 0;
        this.generatedColumn = 0;
        this.source = null;
        this.originalLine = null;
        this.originalColumn = null;
        this.name = null;
      }
      __name(Mapping, "Mapping");
      BasicSourceMapConsumer.prototype._parseMappings = /* @__PURE__ */ __name(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 cachedSegments = {};
        var temp = {};
        var originalMappings = [];
        var generatedMappings = [];
        var mapping, str, segment, end, value;
        while (index < length) {
          if (aStr.charAt(index) === ";") {
            generatedLine++;
            index++;
            previousGeneratedColumn = 0;
          } else if (aStr.charAt(index) === ",") {
            index++;
          } else {
            mapping = new Mapping();
            mapping.generatedLine = generatedLine;
            for (end = index; end < length; end++) {
              if (this._charIsMappingSeparator(aStr, end)) {
                break;
              }
            }
            str = aStr.slice(index, end);
            segment = cachedSegments[str];
            if (segment) {
              index += str.length;
            } else {
              segment = [];
              while (index < end) {
                base64VLQ.decode(aStr, index, temp);
                value = temp.value;
                index = temp.rest;
                segment.push(value);
              }
              if (segment.length === 2) {
                throw new Error("Found a source, but no line and column");
              }
              if (segment.length === 3) {
                throw new Error("Found a source and line, but no column");
              }
              cachedSegments[str] = segment;
            }
            mapping.generatedColumn = previousGeneratedColumn + segment[0];
            previousGeneratedColumn = mapping.generatedColumn;
            if (segment.length > 1) {
              mapping.source = previousSource + segment[1];
              previousSource += segment[1];
              mapping.originalLine = previousOriginalLine + segment[2];
              previousOriginalLine = mapping.originalLine;
              mapping.originalLine += 1;
              mapping.originalColumn = previousOriginalColumn + segment[3];
              previousOriginalColumn = mapping.originalColumn;
              if (segment.length > 4) {
                mapping.name = previousName + segment[4];
                previousName += segment[4];
              }
            }
            generatedMappings.push(mapping);
            if (typeof mapping.originalLine === "number") {
              originalMappings.push(mapping);
            }
          }
        }
        quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
        this.__generatedMappings = generatedMappings;
        quickSort(originalMappings, util.compareByOriginalPositions);
        this.__originalMappings = originalMappings;
      }, "SourceMapConsumer_parseMappings");
      BasicSourceMapConsumer.prototype._findMapping = /* @__PURE__ */ __name(function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
        if (aNeedle[aLineName] <= 0) {
          throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
        }
        if (aNeedle[aColumnName] < 0) {
          throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
        }
        return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
      }, "SourceMapConsumer_findMapping");
      BasicSourceMapConsumer.prototype.computeColumnSpans = /* @__PURE__ */ __name(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;
        }
      }, "SourceMapConsumer_computeColumnSpans");
      BasicSourceMapConsumer.prototype.originalPositionFor = /* @__PURE__ */ __name(function SourceMapConsumer_originalPositionFor(aArgs) {
        var needle = {
          generatedLine: util.getArg(aArgs, "line"),
          generatedColumn: util.getArg(aArgs, "column")
        };
        var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
        if (index >= 0) {
          var mapping = this._generatedMappings[index];
          if (mapping.generatedLine === needle.generatedLine) {
            var source = util.getArg(mapping, "source", null);
            if (source !== null) {
              source = this._sources.at(source);
              if (this.sourceRoot != null) {
                source = util.join(this.sourceRoot, source);
              }
            }
            var name = util.getArg(mapping, "name", null);
            if (name !== null) {
              name = this._names.at(name);
            }
            return {
              source,
              line: util.getArg(mapping, "originalLine", null),
              column: util.getArg(mapping, "originalColumn", null),
              name
            };
          }
        }
        return {
          source: null,
          line: null,
          column: null,
          name: null
        };
      }, "SourceMapConsumer_originalPositionFor");
      BasicSourceMapConsumer.prototype.hasContentsOfAllSources = /* @__PURE__ */ __name(function BasicSourceMapConsumer_hasContentsOfAllSources() {
        if (!this.sourcesContent) {
          return false;
        }
        return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
          return sc == null;
        });
      }, "BasicSourceMapConsumer_hasContentsOfAllSources");
      BasicSourceMapConsumer.prototype.sourceContentFor = /* @__PURE__ */ __name(function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
        if (!this.sourcesContent) {
          return null;
        }
        if (this.sourceRoot != null) {
          aSource = util.relative(this.sourceRoot, aSource);
        }
        if (this._sources.has(aSource)) {
          return this.sourcesContent[this._sources.indexOf(aSource)];
        }
        var url;
        if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
          var fileUriAbsPath = aSource.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("/" + aSource)) {
            return this.sourcesContent[this._sources.indexOf("/" + aSource)];
          }
        }
        if (nullOnMissing) {
          return null;
        } else {
          throw new Error('"' + aSource + '" is not in the SourceMap.');
        }
      }, "SourceMapConsumer_sourceContentFor");
      BasicSourceMapConsumer.prototype.generatedPositionFor = /* @__PURE__ */ __name(function SourceMapConsumer_generatedPositionFor(aArgs) {
        var source = util.getArg(aArgs, "source");
        if (this.sourceRoot != null) {
          source = util.relative(this.sourceRoot, source);
        }
        if (!this._sources.has(source)) {
          return {
            line: null,
            column: null,
            lastColumn: null
          };
        }
        source = this._sources.indexOf(source);
        var needle = {
          source,
          originalLine: util.getArg(aArgs, "line"),
          originalColumn: util.getArg(aArgs, "column")
        };
        var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
        if (index >= 0) {
          var mapping = this._originalMappings[index];
          if (mapping.source === needle.source) {
            return {
              line: util.getArg(mapping, "generatedLine", null),
              column: util.getArg(mapping, "generatedColumn", null),
              lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
            };
          }
        }
        return {
          line: null,
          column: null,
          lastColumn: null
        };
      }, "SourceMapConsumer_generatedPositionFor");
      exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
      function IndexedSourceMapConsumer(aSourceMap) {
        var sourceMap = aSourceMap;
        if (typeof aSourceMap === "string") {
          sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ""));
        }
        var version = util.getArg(sourceMap, "version");
        var sections = util.getArg(sourceMap, "sections");
        if (version != this._version) {
          throw new Error("Unsupported version: " + version);
        }
        this._sources = new ArraySet();
        this._names = new ArraySet();
        var lastOffset = {
          line: -1,
          column: 0
        };
        this._sections = sections.map(function(s) {
          if (s.url) {
            throw new Error("Support for url field in sections not implemented.");
          }
          var offset = util.getArg(s, "offset");
          var offsetLine = util.getArg(offset, "line");
          var offsetColumn = util.getArg(offset, "column");
          if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
            throw new Error("Section offsets must be ordered and non-overlapping.");
          }
          lastOffset = offset;
          return {
            generatedOffset: {
              generatedLine: offsetLine + 1,
              generatedColumn: offsetColumn + 1
            },
            consumer: new SourceMapConsumer(util.getArg(s, "map"))
          };
        });
      }
      __name(IndexedSourceMapConsumer, "IndexedSourceMapConsumer");
      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 = /* @__PURE__ */ __name(function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
        var needle = {
          generatedLine: util.getArg(aArgs, "line"),
          generatedColumn: util.getArg(aArgs, "column")
        };
        var sectionIndex = binarySearch.search(needle, this._sections, function(needle2, section2) {
          var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine;
          if (cmp) {
            return cmp;
          }
          return needle2.generatedColumn - section2.generatedOffset.generatedColumn;
        });
        var section = this._sections[sectionIndex];
        if (!section) {
          return {
            source: null,
            line: null,
            column: null,
            name: null
          };
        }
        return section.consumer.originalPositionFor({
          line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
          column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
          bias: aArgs.bias
        });
      }, "IndexedSourceMapConsumer_originalPositionFor");
      IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = /* @__PURE__ */ __name(function IndexedSourceMapConsumer_hasContentsOfAllSources() {
        return this._sections.every(function(s) {
          return s.consumer.hasContentsOfAllSources();
        });
      }, "IndexedSourceMapConsumer_hasContentsOfAllSources");
      IndexedSourceMapConsumer.prototype.sourceContentFor = /* @__PURE__ */ __name(function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
        for (var i = 0; i < this._sections.length; i++) {
          var section = this._sections[i];
          var content = section.consumer.sourceContentFor(aSource, true);
          if (content) {
            return content;
          }
        }
        if (nullOnMissing) {
          return null;
        } else {
          throw new Error('"' + aSource + '" is not in the SourceMap.');
        }
      }, "IndexedSourceMapConsumer_sourceContentFor");
      IndexedSourceMapConsumer.prototype.generatedPositionFor = /* @__PURE__ */ __name(function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
        for (var i = 0; i < this._sections.length; i++) {
          var section = this._sections[i];
          if (section.consumer.sources.indexOf(util.getArg(aArgs, "source")) === -1) {
            continue;
          }
          var generatedPosition = section.consumer.generatedPositionFor(aArgs);
          if (generatedPosition) {
            var ret = {
              line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
              column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
            };
            return ret;
          }
        }
        return {
          line: null,
          column: null
        };
      }, "IndexedSourceMapConsumer_generatedPositionFor");
      IndexedSourceMapConsumer.prototype._parseMappings = /* @__PURE__ */ __name(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 (section.consumer.sourceRoot !== null) {
              source = util.join(section.consumer.sourceRoot, source);
            }
            this._sources.add(source);
            source = this._sources.indexOf(source);
            var name = section.consumer._names.at(mapping.name);
            this._names.add(name);
            name = this._names.indexOf(name);
            var adjustedMapping = {
              source,
              generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
              generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
              originalLine: mapping.originalLine,
              originalColumn: mapping.originalColumn,
              name
            };
            this.__generatedMappings.push(adjustedMapping);
            if (typeof adjustedMapping.originalLine === "number") {
              this.__originalMappings.push(adjustedMapping);
            }
          }
        }
        quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
        quickSort(this.__originalMappings, util.compareByOriginalPositions);
      }, "IndexedSourceMapConsumer_parseMappings");
      exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
    }
  });

  // node_modules/stacktrace-gps/stacktrace-gps.js
  var require_stacktrace_gps = __commonJS({
    "node_modules/stacktrace-gps/stacktrace-gps.js"(exports, module) {
      (function(root, factory) {
        "use strict";
        if (typeof define === "function" && define.amd) {
          define("stacktrace-gps", ["source-map", "stackframe"], factory);
        } else if (typeof exports === "object") {
          module.exports = factory(require_source_map_consumer(), require_stackframe());
        } else {
          root.StackTraceGPS = factory(root.SourceMap || root.sourceMap, root.StackFrame);
        }
      })(exports, function(SourceMap, StackFrame) {
        "use strict";
        function _xdr(url) {
          return new Promise(function(resolve, reject) {
            var req = new XMLHttpRequest();
            req.open("get", url);
            req.onerror = reject;
            req.onreadystatechange = /* @__PURE__ */ __name(function onreadystatechange() {
              if (req.readyState === 4) {
                if (req.status >= 200 && req.status < 300 || url.substr(0, 7) === "file://" && req.responseText) {
                  resolve(req.responseText);
                } else {
                  reject(new Error("HTTP status: " + req.status + " retrieving " + url));
                }
              }
            }, "onreadystatechange");
            req.send();
          });
        }
        __name(_xdr, "_xdr");
        function _atob(b64str) {
          if (typeof window !== "undefined" && window.atob) {
            return window.atob(b64str);
          } else {
            throw new Error("You must supply a polyfill for window.atob in this environment");
          }
        }
        __name(_atob, "_atob");
        function _parseJson(string) {
          if (typeof JSON !== "undefined" && JSON.parse) {
            return JSON.parse(string);
          } else {
            throw new Error("You must supply a polyfill for JSON.parse in this environment");
          }
        }
        __name(_parseJson, "_parseJson");
        function _findFunctionName(source, lineNumber) {
          var syntaxes = [
            /['"]?([$_A-Za-z][$_A-Za-z0-9]*)['"]?\s*[:=]\s*function\b/,
            /function\s+([^('"`]*?)\s*\(([^)]*)\)/,
            /['"]?([$_A-Za-z][$_A-Za-z0-9]*)['"]?\s*[:=]\s*(?:eval|new Function)\b/,
            /\b(?!(?:if|for|switch|while|with|catch)\b)(?:(?:static)\s+)?(\S+)\s*\(.*?\)\s*\{/,
            /['"]?([$_A-Za-z][$_A-Za-z0-9]*)['"]?\s*[:=]\s*\(.*?\)\s*=>/
          ];
          var lines = source.split("\n");
          var code = "";
          var maxLines = Math.min(lineNumber, 20);
          for (var i = 0; i < maxLines; ++i) {
            var line = lines[lineNumber - i - 1];
            var commentPos = line.indexOf("//");
            if (commentPos >= 0) {
              line = line.substr(0, commentPos);
            }
            if (line) {
              code = line + code;
              var len = syntaxes.length;
              for (var index = 0; index < len; index++) {
                var m = syntaxes[index].exec(code);
                if (m && m[1]) {
                  return m[1];
                }
              }
            }
          }
          return void 0;
        }
        __name(_findFunctionName, "_findFunctionName");
        function _ensureSupportedEnvironment() {
          if (typeof Object.defineProperty !== "function" || typeof Object.create !== "function") {
            throw new Error("Unable to consume source maps in older browsers");
          }
        }
        __name(_ensureSupportedEnvironment, "_ensureSupportedEnvironment");
        function _ensureStackFrameIsLegit(stackframe) {
          if (typeof stackframe !== "object") {
            throw new TypeError("Given StackFrame is not an object");
          } else if (typeof stackframe.fileName !== "string") {
            throw new TypeError("Given file name is not a String");
          } else if (typeof stackframe.lineNumber !== "number" || stackframe.lineNumber % 1 !== 0 || stackframe.lineNumber < 1) {
            throw new TypeError("Given line number must be a positive integer");
          } else if (typeof stackframe.columnNumber !== "number" || stackframe.columnNumber % 1 !== 0 || stackframe.columnNumber < 0) {
            throw new TypeError("Given column number must be a non-negative integer");
          }
          return true;
        }
        __name(_ensureStackFrameIsLegit, "_ensureStackFrameIsLegit");
        function _findSourceMappingURL(source) {
          var sourceMappingUrlRegExp = /\/\/[#@] ?sourceMappingURL=([^\s'"]+)\s*$/mg;
          var lastSourceMappingUrl;
          var matchSourceMappingUrl;
          while (matchSourceMappingUrl = sourceMappingUrlRegExp.exec(source)) {
            lastSourceMappingUrl = matchSourceMappingUrl[1];
          }
          if (lastSourceMappingUrl) {
            return lastSourceMappingUrl;
          } else {
            throw new Error("sourceMappingURL not found");
          }
        }
        __name(_findSourceMappingURL, "_findSourceMappingURL");
        function _extractLocationInfoFromSourceMapSource(stackframe, sourceMapConsumer, sourceCache) {
          return new Promise(function(resolve, reject) {
            var loc = sourceMapConsumer.originalPositionFor({
              line: stackframe.lineNumber,
              column: stackframe.columnNumber
            });
            if (loc.source) {
              var mappedSource = sourceMapConsumer.sourceContentFor(loc.source);
              if (mappedSource) {
                sourceCache[loc.source] = mappedSource;
              }
              resolve(new StackFrame({
                functionName: loc.name || stackframe.functionName,
                args: stackframe.args,
                fileName: loc.source,
                lineNumber: loc.line,
                columnNumber: loc.column
              }));
            } else {
              reject(new Error("Could not get original source for given stackframe and source map"));
            }
          });
        }
        __name(_extractLocationInfoFromSourceMapSource, "_extractLocationInfoFromSourceMapSource");
        return /* @__PURE__ */ __name(function StackTraceGPS(opts) {
          if (!(this instanceof StackTraceGPS)) {
            return new StackTraceGPS(opts);
          }
          opts = opts || {};
          this.sourceCache = opts.sourceCache || {};
          this.sourceMapConsumerCache = opts.sourceMapConsumerCache || {};
          this.ajax = opts.ajax || _xdr;
          this._atob = opts.atob || _atob;
          this._get = /* @__PURE__ */ __name(function _get(location2) {
            return new Promise(function(resolve, reject) {
              var isDataUrl = location2.substr(0, 5) === "data:";
              if (this.sourceCache[location2]) {
                resolve(this.sourceCache[location2]);
              } else if (opts.offline && !isDataUrl) {
                reject(new Error("Cannot make network requests in offline mode"));
              } else {
                if (isDataUrl) {
                  var supportedEncodingRegexp = /^data:application\/json;([\w=:"-]+;)*base64,/;
                  var match = location2.match(supportedEncodingRegexp);
                  if (match) {
                    var sourceMapStart = match[0].length;
                    var encodedSource = location2.substr(sourceMapStart);
                    var source = this._atob(encodedSource);
                    this.sourceCache[location2] = source;
                    resolve(source);
                  } else {
                    reject(new Error("The encoding of the inline sourcemap is not supported"));
                  }
                } else {
                  var xhrPromise = this.ajax(location2, { method: "get" });
                  this.sourceCache[location2] = xhrPromise;
                  xhrPromise.then(resolve, reject);
                }
              }
            }.bind(this));
          }, "_get");
          this._getSourceMapConsumer = /* @__PURE__ */ __name(function _getSourceMapConsumer(sourceMappingURL, defaultSourceRoot) {
            return new Promise(function(resolve) {
              if (this.sourceMapConsumerCache[sourceMappingURL]) {
                resolve(this.sourceMapConsumerCache[sourceMappingURL]);
              } else {
                var sourceMapConsumerPromise = new Promise(function(resolve2, reject) {
                  return this._get(sourceMappingURL).then(function(sourceMapSource) {
                    if (typeof sourceMapSource === "string") {
                      sourceMapSource = _parseJson(sourceMapSource.replace(/^\)\]\}'/, ""));
                    }
                    if (typeof sourceMapSource.sourceRoot === "undefined") {
                      sourceMapSource.sourceRoot = defaultSourceRoot;
                    }
                    resolve2(new SourceMap.SourceMapConsumer(sourceMapSource));
                  }, reject);
                }.bind(this));
                this.sourceMapConsumerCache[sourceMappingURL] = sourceMapConsumerPromise;
                resolve(sourceMapConsumerPromise);
              }
            }.bind(this));
          }, "_getSourceMapConsumer");
          this.pinpoint = /* @__PURE__ */ __name(function StackTraceGPS$$pinpoint(stackframe) {
            return new Promise(function(resolve, reject) {
              this.getMappedLocation(stackframe).then(function(mappedStackFrame) {
                function resolveMappedStackFrame() {
                  resolve(mappedStackFrame);
                }
                __name(resolveMappedStackFrame, "resolveMappedStackFrame");
                this.findFunctionName(mappedStackFrame).then(resolve, resolveMappedStackFrame)["catch"](resolveMappedStackFrame);
              }.bind(this), reject);
            }.bind(this));
          }, "StackTraceGPS$$pinpoint");
          this.findFunctionName = /* @__PURE__ */ __name(function StackTraceGPS$$findFunctionName(stackframe) {
            return new Promise(function(resolve, reject) {
              _ensureStackFrameIsLegit(stackframe);
              this._get(stackframe.fileName).then(/* @__PURE__ */ __name(function getSourceCallback(source) {
                var lineNumber = stackframe.lineNumber;
                var columnNumber = stackframe.columnNumber;
                var guessedFunctionName = _findFunctionName(source, lineNumber, columnNumber);
                if (guessedFunctionName) {
                  resolve(new StackFrame({
                    functionName: guessedFunctionName,
                    args: stackframe.args,
                    fileName: stackframe.fileName,
                    lineNumber,
                    columnNumber
                  }));
                } else {
                  resolve(stackframe);
                }
              }, "getSourceCallback"), reject)["catch"](reject);
            }.bind(this));
          }, "StackTraceGPS$$findFunctionName");
          this.getMappedLocation = /* @__PURE__ */ __name(function StackTraceGPS$$getMappedLocation(stackframe) {
            return new Promise(function(resolve, reject) {
              _ensureSupportedEnvironment();
              _ensureStackFrameIsLegit(stackframe);
              var sourceCache = this.sourceCache;
              var fileName = stackframe.fileName;
              this._get(fileName).then(function(source) {
                var sourceMappingURL = _findSourceMappingURL(source);
                var isDataUrl = sourceMappingURL.substr(0, 5) === "data:";
                var defaultSourceRoot = fileName.substring(0, fileName.lastIndexOf("/") + 1);
                if (sourceMappingURL[0] !== "/" && !isDataUrl && !/^https?:\/\/|^\/\//i.test(sourceMappingURL)) {
                  sourceMappingURL = defaultSourceRoot + sourceMappingURL;
                }
                return this._getSourceMapConsumer(sourceMappingURL, defaultSourceRoot).then(function(sourceMapConsumer) {
                  return _extractLocationInfoFromSourceMapSource(stackframe, sourceMapConsumer, sourceCache).then(resolve)["catch"](function() {
                    resolve(stackframe);
                  });
                });
              }.bind(this), reject)["catch"](reject);
            }.bind(this));
          }, "StackTraceGPS$$getMappedLocation");
        }, "StackTraceGPS");
      });
    }
  });

  // node_modules/stacktrace-js/stacktrace.js
  var require_stacktrace = __commonJS({
    "node_modules/stacktrace-js/stacktrace.js"(exports, module) {
      (function(root, factory) {
        "use strict";
        if (typeof define === "function" && define.amd) {
          define("stacktrace", ["error-stack-parser", "stack-generator", "stacktrace-gps"], factory);
        } else if (typeof exports === "object") {
          module.exports = factory(require_error_stack_parser(), require_stack_generator(), require_stacktrace_gps());
        } else {
          root.StackTrace = factory(root.ErrorStackParser, root.StackGenerator, root.StackTraceGPS);
        }
      })(exports, /* @__PURE__ */ __name(function StackTrace2(ErrorStackParser, StackGenerator, StackTraceGPS) {
        var _options = {
          filter: function(stackframe) {
            return (stackframe.functionName || "").indexOf("StackTrace$$") === -1 && (stackframe.functionName || "").indexOf("ErrorStackParser$$") === -1 && (stackframe.functionName || "").indexOf("StackTraceGPS$$") === -1 && (stackframe.functionName || "").indexOf("StackGenerator$$") === -1;
          },
          sourceCache: {}
        };
        var _generateError = /* @__PURE__ */ __name(function StackTrace$$GenerateError() {
          try {
            throw new Error();
          } catch (err) {
            return err;
          }
        }, "StackTrace$$GenerateError");
        function _merge(first, second) {
          var target = {};
          [first, second].forEach(function(obj) {
            for (var prop in obj) {
              if (Object.prototype.hasOwnProperty.call(obj, prop)) {
                target[prop] = obj[prop];
              }
            }
            return target;
          });
          return target;
        }
        __name(_merge, "_merge");
        function _isShapedLikeParsableError(err) {
          return err.stack || err["opera#sourceloc"];
        }
        __name(_isShapedLikeParsableError, "_isShapedLikeParsableError");
        function _filtered(stackframes, filter) {
          if (typeof filter === "function") {
            return stackframes.filter(filter);
          }
          return stackframes;
        }
        __name(_filtered, "_filtered");
        return {
          get: /* @__PURE__ */ __name(function StackTrace$$get(opts) {
            var err = _generateError();
            return _isShapedLikeParsableError(err) ? this.fromError(err, opts) : this.generateArtificially(opts);
          }, "StackTrace$$get"),
          getSync: /* @__PURE__ */ __name(function StackTrace$$getSync(opts) {
            opts = _merge(_options, opts);
            var err = _generateError();
            var stack = _isShapedLikeParsableError(err) ? ErrorStackParser.parse(err) : StackGenerator.backtrace(opts);
            return _filtered(stack, opts.filter);
          }, "StackTrace$$getSync"),
          fromError: /* @__PURE__ */ __name(function StackTrace$$fromError(error, opts) {
            opts = _merge(_options, opts);
            var gps = new StackTraceGPS(opts);
            return new Promise(function(resolve) {
              var stackframes = _filtered(ErrorStackParser.parse(error), opts.filter);
              resolve(Promise.all(stackframes.map(function(sf) {
                return new Promise(function(resolve2) {
                  function resolveOriginal() {
                    resolve2(sf);
                  }
                  __name(resolveOriginal, "resolveOriginal");
                  gps.pinpoint(sf).then(resolve2, resolveOriginal)["catch"](resolveOriginal);
                });
              })));
            }.bind(this));
          }, "StackTrace$$fromError"),
          generateArtificially: /* @__PURE__ */ __name(function StackTrace$$generateArtificially(opts) {
            opts = _merge(_options, opts);
            var stackFrames = StackGenerator.backtrace(opts);
            if (typeof opts.filter === "function") {
              stackFrames = stackFrames.filter(opts.filter);
            }
            return Promise.resolve(stackFrames);
          }, "StackTrace$$generateArtificially"),
          instrument: /* @__PURE__ */ __name(function StackTrace$$instrument(fn, callback, errback, thisArg) {
            if (typeof fn !== "function") {
              throw new Error("Cannot instrument non-function object");
            } else if (typeof fn.__stacktraceOriginalFn === "function") {
              return fn;
            }
            var instrumented = (/* @__PURE__ */ __name(function StackTrace$$instrumented() {
              try {
                this.get().then(callback, errback)["catch"](errback);
                return fn.apply(thisArg || this, arguments);
              } catch (e) {
                if (_isShapedLikeParsableError(e)) {
                  this.fromError(e).then(callback, errback)["catch"](errback);
                }
                throw e;
              }
            }, "StackTrace$$instrumented")).bind(this);
            instrumented.__stacktraceOriginalFn = fn;
            return instrumented;
          }, "StackTrace$$instrument"),
          deinstrument: /* @__PURE__ */ __name(function StackTrace$$deinstrument(fn) {
            if (typeof fn !== "function") {
              throw new Error("Cannot de-instrument non-function object");
            } else if (typeof fn.__stacktraceOriginalFn === "function") {
              return fn.__stacktraceOriginalFn;
            } else {
              return fn;
            }
          }, "StackTrace$$deinstrument"),
          report: /* @__PURE__ */ __name(function StackTrace$$report(stackframes, url, errorMsg, requestOptions) {
            return new Promise(function(resolve, reject) {
              var req = new XMLHttpRequest();
              req.onerror = reject;
              req.onreadystatechange = /* @__PURE__ */ __name(function onreadystatechange() {
                if (req.readyState === 4) {
                  if (req.status >= 200 && req.status < 400) {
                    resolve(req.responseText);
                  } else {
                    reject(new Error("POST to " + url + " failed with status: " + req.status));
                  }
                }
              }, "onreadystatechange");
              req.open("post", url);
              req.setRequestHeader("Content-Type", "application/json");
              if (requestOptions && typeof requestOptions.headers === "object") {
                var headers = requestOptions.headers;
                for (var header in headers) {
                  if (Object.prototype.hasOwnProperty.call(headers, header)) {
                    req.setRequestHeader(header, headers[header]);
                  }
                }
              }
              var reportPayload = { stack: stackframes };
              if (errorMsg !== void 0 && errorMsg !== null) {
                reportPayload.message = errorMsg;
              }
              req.send(JSON.stringify(reportPayload));
            });
          }, "StackTrace$$report")
        };
      }, "StackTrace"));
    }
  });

  // helper.ts
  var import_stacktrace_js = __toESM(require_stacktrace());
  window.addEventListener("error", (e) => {
    import_stacktrace_js.default.fromError(e.error).then((stack) => {
      fetch("/error", {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify({
          msg: e.error.message,
          stack: stack.slice(0, 4).map((step) => {
            return __spreadProps(__spreadValues({}, step), {
              file: step.fileName.replace(location.origin + "/", ""),
              line: step.lineNumber,
              col: step.columnNumber
            });
          })
        })
      });
    }).catch(() => console.error("failed to parse err"));
  });
  var replit = {
    getUser() {
      return fetch("/user").then((res) => res.json()).then((user) => {
        if (user) {
          return Promise.resolve(user);
        } else {
          return Promise.resolve(null);
        }
      });
    },
    auth() {
      return new Promise((resolve, reject) => {
        const authComplete = /* @__PURE__ */ __name((e) => {
          if (e.data !== "auth_complete") {
            resolve(null);
            return;
          }
          window.removeEventListener("message", authComplete);
          authWindow.close();
          this.getUser().then(resolve);
        }, "authComplete");
        window.addEventListener("message", authComplete);
        const w = 320;
        const h = 480;
        const left = screen.width / 2 - w / 2;
        const top = screen.height / 2 - h / 2;
        const authWindow = window.open(`https://repl.it/auth_with_repl_site?domain=${location.host}`, "_blank", `modal=yes, toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, copyhistory=no, width=${w}, height=${h}, top=${top}, left=${left}`);
      });
    },
    getUserOrAuth() {
      return new Promise((resolve, reject) => {
        this.getUser().then((user) => {
          if (user) {
            resolve(user);
          } else {
            this.auth().then((user2) => {
              resolve(user2);
            });
          }
        });
      });
    },
    getData(key, def) {
      return fetch(`/db/${key}`).then((res) => res.json()).then((val) => {
        if (val == null && def !== void 0) {
          return this.setData(key, def);
        }
        return Promise.resolve(val);
      });
    },
    setData(key, val) {
      return fetch(`/db/${key}`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify(val)
      }).then(() => Promise.resolve(val));
    },
    delData(key) {
      return fetch(`/db/${key}`, {
        method: "DELETE"
      }).then(() => {
      });
    },
    listData() {
      return fetch(`/db`).then((res) => res.json());
    },
    clearData() {
      return fetch(`/db`, {
        method: "DELETE"
      }).then((res) => {
      });
    }
  };
  window.replit = replit;
})();
//# sourceMappingURL=helper.js.map